Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Entrypoint", "for", "compare_layers" ]

[ "def", "main", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Tool for testing caffe to mxnet conversion layer by layer'", ")", "parser", ".", "add_argument", "(", "'--image_url'", ",", "type", "=", "str", ",", "default", "=", "'https://github.com/dmlc/web-data/raw/master/mxnet/doc/'", "'tutorials/python/predict_image/cat.jpg'", ",", "help", "=", "'input image to test inference, can be either file path or url'", ")", "parser", ".", "add_argument", "(", "'--caffe_prototxt_path'", ",", "type", "=", "str", ",", "default", "=", "'./model.prototxt'", ",", "help", "=", "'path to caffe prototxt'", ")", "parser", ".", "add_argument", "(", "'--caffe_model_path'", ",", "type", "=", "str", ",", "default", "=", "'./model.caffemodel'", ",", "help", "=", "'path to caffe weights'", ")", "parser", ".", "add_argument", "(", "'--caffe_mean'", ",", "type", "=", "str", ",", "default", "=", "'./model_mean.binaryproto'", ",", "help", "=", "'path to caffe mean file'", ")", "parser", ".", "add_argument", "(", "'--mean_diff_allowed'", ",", "type", "=", "int", ",", "default", "=", "1e-03", ",", "help", "=", "'mean difference allowed between caffe blob and mxnet blob'", ")", "parser", ".", "add_argument", "(", "'--max_diff_allowed'", ",", "type", "=", "int", ",", "default", "=", "1e-01", ",", "help", "=", "'max difference allowed between caffe blob and mxnet blob'", ")", "parser", ".", "add_argument", "(", "'--gpu'", ",", "type", "=", "int", ",", "default", "=", "-", "1", ",", "help", "=", "'the gpu id used for predict'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "convert_and_compare_caffe_to_mxnet", "(", "args", ".", "image_url", ",", "args", ".", "gpu", ",", "args", ".", "caffe_prototxt_path", ",", "args", ".", "caffe_model_path", ",", "args", ".", "caffe_mean", ",", "args", ".", "mean_diff_allowed", ",", "args", ".", "max_diff_allowed", ")" ]

[ "Converts", "datetime", "to", "Timestamp", "." ]

[ "def", "FromDatetime", "(", "self", ",", "dt", ")", ":", "# Using this guide: http://wiki.python.org/moin/WorkingWithTime", "# And this conversion guide: http://docs.python.org/library/time.html", "# Turn the date parameter into a tuple (struct_time) that can then be", "# manipulated into a long value of seconds. During the conversion from", "# struct_time to long, the source date in UTC, and so it follows that the", "# correct transformation is calendar.timegm()", "self", ".", "seconds", "=", "calendar", ".", "timegm", "(", "dt", ".", "utctimetuple", "(", ")", ")", "self", ".", "nanos", "=", "dt", ".", "microsecond", "*", "_NANOS_PER_MICROSECOND" ]

[ "Clip", "gradients", "according", "to", "the", "clipnorm", "and", "clipvalue", "attributes", "." ]

[ "def", "_clip_gradients", "(", "self", ",", "grads", ")", ":", "# TFOptimizer wrapper has no gradient clipping options.", "return", "grads" ]

[ "GetAbsoluteRange", "(", "self", ")", "-", ">", "RichTextRange" ]

[ "def", "GetAbsoluteRange", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextLine_GetAbsoluteRange", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "the", "status", "of", "a", "file", "." ]

[ "def", "GetStatus", "(", "self", ",", "filename", ")", ":", "if", "not", "self", ".", "options", ".", "revision", ":", "status", "=", "RunShell", "(", "[", "\"svn\"", ",", "\"status\"", ",", "\"--ignore-externals\"", ",", "self", ".", "_EscapeFilename", "(", "filename", ")", "]", ")", "if", "not", "status", ":", "ErrorExit", "(", "\"svn status returned no output for %s\"", "%", "filename", ")", "status_lines", "=", "status", ".", "splitlines", "(", ")", "# If file is in a cl, the output will begin with", "# \"\\n--- Changelist 'cl_name':\\n\". See", "# http://svn.collab.net/repos/svn/trunk/notes/changelist-design.txt", "if", "(", "len", "(", "status_lines", ")", "==", "3", "and", "not", "status_lines", "[", "0", "]", "and", "status_lines", "[", "1", "]", ".", "startswith", "(", "\"--- Changelist\"", ")", ")", ":", "status", "=", "status_lines", "[", "2", "]", "else", ":", "status", "=", "status_lines", "[", "0", "]", "# If we have a revision to diff against we need to run \"svn list\"", "# for the old and the new revision and compare the results to get", "# the correct status for a file.", "else", ":", "dirname", ",", "relfilename", "=", "os", ".", "path", ".", "split", "(", "filename", ")", "if", "dirname", "not", "in", "self", ".", "svnls_cache", ":", "cmd", "=", "[", "\"svn\"", ",", "\"list\"", ",", "\"-r\"", ",", "self", ".", "rev_start", ",", "self", ".", "_EscapeFilename", "(", "dirname", ")", "or", "\".\"", "]", "out", ",", "err", ",", "returncode", "=", "RunShellWithReturnCodeAndStderr", "(", "cmd", ")", "if", "returncode", ":", "# Directory might not yet exist at start revison", "# svn: Unable to find repository location for 'abc' in revision nnn", "if", "re", ".", "match", "(", "'^svn: Unable to find repository location for .+ in revision \\d+'", ",", "err", ")", ":", "old_files", "=", "(", ")", "else", ":", "ErrorExit", "(", "\"Failed to get status for %s:\\n%s\"", "%", "(", "filename", ",", "err", ")", ")", "else", ":", "old_files", "=", "out", ".", "splitlines", "(", ")", "args", "=", "[", "\"svn\"", ",", "\"list\"", "]", "if", "self", ".", "rev_end", ":", "args", "+=", "[", "\"-r\"", ",", "self", ".", "rev_end", "]", "cmd", "=", "args", "+", "[", "self", ".", "_EscapeFilename", "(", "dirname", ")", "or", "\".\"", "]", "out", ",", "returncode", "=", "RunShellWithReturnCode", "(", "cmd", ")", "if", "returncode", ":", "ErrorExit", "(", "\"Failed to run command %s\"", "%", "cmd", ")", "self", ".", "svnls_cache", "[", "dirname", "]", "=", "(", "old_files", ",", "out", ".", "splitlines", "(", ")", ")", "old_files", ",", "new_files", "=", "self", ".", "svnls_cache", "[", "dirname", "]", "if", "relfilename", "in", "old_files", "and", "relfilename", "not", "in", "new_files", ":", "status", "=", "\"D \"", "elif", "relfilename", "in", "old_files", "and", "relfilename", "in", "new_files", ":", "status", "=", "\"M \"", "else", ":", "status", "=", "\"A \"", "return", "status" ]

[ "value", "--", "a", "value", "to", "read", "from", "for", "stringio" ]

[ "def", "__init__", "(", "self", ",", "value", "=", "None", ",", "offset", "=", "0", ")", ":", "if", "value", "is", "not", "None", ":", "self", ".", "_buffer", "=", "BufferIO", "(", "value", ")", "else", ":", "self", ".", "_buffer", "=", "BufferIO", "(", ")", "if", "offset", ":", "self", ".", "_buffer", ".", "seek", "(", "offset", ")" ]

[ "TpmMarshaller", "method" ]

[ "def", "initFromTpm", "(", "self", ",", "buf", ")", ":", "self", ".", "magic", "=", "buf", ".", "readInt", "(", ")", "type", "=", "buf", ".", "readShort", "(", ")", "self", ".", "qualifiedSigner", "=", "buf", ".", "readSizedByteBuf", "(", ")", "self", ".", "extraData", "=", "buf", ".", "readSizedByteBuf", "(", ")", "self", ".", "clockInfo", "=", "TPMS_CLOCK_INFO", ".", "fromTpm", "(", "buf", ")", "self", ".", "firmwareVersion", "=", "buf", ".", "readInt64", "(", ")", "self", ".", "attested", "=", "UnionFactory", ".", "create", "(", "'TPMU_ATTEST'", ",", "type", ")", "self", ".", "attested", ".", "initFromTpm", "(", "buf", ")" ]

[ "Prints", "message", "and", "the", "tensor", "value", "when", "evaluated", "." ]

[ "def", "print_tensor", "(", "x", ",", "message", "=", "''", ",", "summarize", "=", "3", ")", ":", "if", "isinstance", "(", "x", ",", "ops", ".", "Tensor", ")", "and", "hasattr", "(", "x", ",", "'graph'", ")", ":", "with", "get_graph", "(", ")", ".", "as_default", "(", ")", ":", "op", "=", "logging_ops", ".", "print_v2", "(", "message", ",", "x", ",", "output_stream", "=", "sys", ".", "stdout", ",", "summarize", "=", "summarize", ")", "with", "ops", ".", "control_dependencies", "(", "[", "op", "]", ")", ":", "return", "array_ops", ".", "identity", "(", "x", ")", "else", ":", "logging_ops", ".", "print_v2", "(", "message", ",", "x", ",", "output_stream", "=", "sys", ".", "stdout", ",", "summarize", "=", "summarize", ")", "return", "x" ]

[ "Return", "a", "new", "copy", "of", "the", "Bits", "for", "the", "copy", "module", "." ]

[ "def", "__copy__", "(", "self", ")", ":", "# Note that if you want a new copy (different ID), use _copy instead.", "# The copy can return self as it's immutable.", "return", "self" ]

[ "Check", "for", "valid", "ABI", "(", "application", "binary", "interface", ")", "name", "and", "map", "into", "canonical", "one" ]

[ "def", "check_abi", "(", "abi", ")", ":", "if", "not", "abi", ":", "return", "None", "abi", "=", "abi", ".", "lower", "(", ")", "# valid_abis maps input name to canonical name", "if", "is_windows", ":", "valid_abis", "=", "{", "'ia32'", ":", "'ia32'", ",", "'x86'", ":", "'ia32'", ",", "'ia64'", ":", "'ia64'", ",", "'em64t'", ":", "'em64t'", ",", "'amd64'", ":", "'em64t'", "}", "if", "is_linux", ":", "valid_abis", "=", "{", "'ia32'", ":", "'ia32'", ",", "'x86'", ":", "'ia32'", ",", "'x86_64'", ":", "'x86_64'", ",", "'em64t'", ":", "'x86_64'", ",", "'amd64'", ":", "'x86_64'", "}", "if", "is_mac", ":", "valid_abis", "=", "{", "'ia32'", ":", "'ia32'", ",", "'x86'", ":", "'ia32'", ",", "'x86_64'", ":", "'x86_64'", ",", "'em64t'", ":", "'x86_64'", "}", "try", ":", "abi", "=", "valid_abis", "[", "abi", "]", "except", "KeyError", ":", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "\"Intel compiler: Invalid ABI %s, valid values are %s\"", "%", "(", "abi", ",", "list", "(", "valid_abis", ".", "keys", "(", ")", ")", ")", ")", "return", "abi" ]

[ "Read", "one", "line", "from", "the", "pseudoterminal", "and", "return", "it", "as", "unicode", "." ]

[ "def", "readline", "(", "self", ")", ":", "b", "=", "super", "(", "PtyProcessUnicode", ",", "self", ")", ".", "readline", "(", ")", "return", "self", ".", "decoder", ".", "decode", "(", "b", ",", "final", "=", "False", ")" ]

[ "Set", "timeout", "of", "a", "positive", "float", "expressing", "seconds", "." ]

[ "def", "SetTimeout", "(", "self", ",", "timeout", ")", ":", "if", "timeout", "<=", "0", ":", "raise", "Error", "(", "'Invalid timeout value, should be a positive float.'", ")", "self", ".", "timeout", "=", "timeout" ]

[ "This", "code", "is", "borrowed", "from", "Ross", "Girshick", "s", "FAST", "-", "RCNN", "code", "(", "https", ":", "//", "github", ".", "com", "/", "rbgirshick", "/", "fast", "-", "rcnn", ")", ".", "It", "parses", "the", "PASCAL", ".", "xml", "metadata", "files", ".", "See", "publication", "for", "further", "details", ":", "(", "http", ":", "//", "arxiv", ".", "org", "/", "abs", "/", "1504", ".", "08083", ")", "." ]

[ "def", "load_pascal_annotation", "(", "index", ",", "pascal_root", ")", ":", "classes", "=", "(", "'__background__'", ",", "# always index 0", "'aeroplane'", ",", "'bicycle'", ",", "'bird'", ",", "'boat'", ",", "'bottle'", ",", "'bus'", ",", "'car'", ",", "'cat'", ",", "'chair'", ",", "'cow'", ",", "'diningtable'", ",", "'dog'", ",", "'horse'", ",", "'motorbike'", ",", "'person'", ",", "'pottedplant'", ",", "'sheep'", ",", "'sofa'", ",", "'train'", ",", "'tvmonitor'", ")", "class_to_ind", "=", "dict", "(", "zip", "(", "classes", ",", "xrange", "(", "21", ")", ")", ")", "filename", "=", "osp", ".", "join", "(", "pascal_root", ",", "'Annotations'", ",", "index", "+", "'.xml'", ")", "# print 'Loading: {}'.format(filename)", "def", "get_data_from_tag", "(", "node", ",", "tag", ")", ":", "return", "node", ".", "getElementsByTagName", "(", "tag", ")", "[", "0", "]", ".", "childNodes", "[", "0", "]", ".", "data", "with", "open", "(", "filename", ")", "as", "f", ":", "data", "=", "minidom", ".", "parseString", "(", "f", ".", "read", "(", ")", ")", "objs", "=", "data", ".", "getElementsByTagName", "(", "'object'", ")", "num_objs", "=", "len", "(", "objs", ")", "boxes", "=", "np", ".", "zeros", "(", "(", "num_objs", ",", "4", ")", ",", "dtype", "=", "np", ".", "uint16", ")", "gt_classes", "=", "np", ".", "zeros", "(", "(", "num_objs", ")", ",", "dtype", "=", "np", ".", "int32", ")", "overlaps", "=", "np", ".", "zeros", "(", "(", "num_objs", ",", "21", ")", ",", "dtype", "=", "np", ".", "float32", ")", "# Load object bounding boxes into a data frame.", "for", "ix", ",", "obj", "in", "enumerate", "(", "objs", ")", ":", "# Make pixel indexes 0-based", "x1", "=", "float", "(", "get_data_from_tag", "(", "obj", ",", "'xmin'", ")", ")", "-", "1", "y1", "=", "float", "(", "get_data_from_tag", "(", "obj", ",", "'ymin'", ")", ")", "-", "1", "x2", "=", "float", "(", "get_data_from_tag", "(", "obj", ",", "'xmax'", ")", ")", "-", "1", "y2", "=", "float", "(", "get_data_from_tag", "(", "obj", ",", "'ymax'", ")", ")", "-", "1", "cls", "=", "class_to_ind", "[", "str", "(", "get_data_from_tag", "(", "obj", ",", "\"name\"", ")", ")", ".", "lower", "(", ")", ".", "strip", "(", ")", "]", "boxes", "[", "ix", ",", ":", "]", "=", "[", "x1", ",", "y1", ",", "x2", ",", "y2", "]", "gt_classes", "[", "ix", "]", "=", "cls", "overlaps", "[", "ix", ",", "cls", "]", "=", "1.0", "overlaps", "=", "scipy", ".", "sparse", ".", "csr_matrix", "(", "overlaps", ")", "return", "{", "'boxes'", ":", "boxes", ",", "'gt_classes'", ":", "gt_classes", ",", "'gt_overlaps'", ":", "overlaps", ",", "'flipped'", ":", "False", ",", "'index'", ":", "index", "}" ]

[ "return", "CompFor", "(", "for", "a", "in", "b", ")" ]

[ "def", "_get_comp_for", "(", "self", ")", ":", "return", "self", ".", "_get_comprehension", "(", ")", ".", "children", "[", "1", "]" ]

[ "Useful", "to", "detect", "the", "Token", "/", "Lexer", "bug" ]

[ "def", "__contains__", "(", "self", ",", "other", ")", ":", "if", "not", "isinstance", "(", "other", ",", "SourceLocation", ")", ":", "return", "False", "if", "other", ".", "file", "is", "None", "and", "self", ".", "start", ".", "file", "is", "None", ":", "pass", "elif", "(", "self", ".", "start", ".", "file", ".", "name", "!=", "other", ".", "file", ".", "name", "or", "other", ".", "file", ".", "name", "!=", "self", ".", "end", ".", "file", ".", "name", ")", ":", "# same file name", "return", "False", "# same file, in between lines", "if", "self", ".", "start", ".", "line", "<", "other", ".", "line", "<", "self", ".", "end", ".", "line", ":", "return", "True", "elif", "self", ".", "start", ".", "line", "==", "other", ".", "line", ":", "# same file first line", "if", "self", ".", "start", ".", "column", "<=", "other", ".", "column", ":", "return", "True", "elif", "other", ".", "line", "==", "self", ".", "end", ".", "line", ":", "# same file last line", "if", "other", ".", "column", "<=", "self", ".", "end", ".", "column", ":", "return", "True", "return", "False" ]

[ "Updates", "this", "variable", "with", "the", "min", "of", "tf", ".", "IndexedSlices", "and", "itself", "." ]

[ "def", "scatter_min", "(", "self", ",", "sparse_delta", ",", "use_locking", "=", "False", ",", "name", "=", "None", ")", ":", "if", "not", "isinstance", "(", "sparse_delta", ",", "indexed_slices", ".", "IndexedSlices", ")", ":", "raise", "TypeError", "(", "\"sparse_delta is not IndexedSlices: %s\"", "%", "sparse_delta", ")", "return", "gen_state_ops", ".", "scatter_min", "(", "self", ".", "_variable", ",", "sparse_delta", ".", "indices", ",", "sparse_delta", ".", "values", ",", "use_locking", "=", "use_locking", ",", "name", "=", "name", ")" ]

[ "onDirtyChanged", "(", "callback", ")", "...", "set", "callback", "when", "dirty", "state", "changes", "." ]

[ "def", "onDirtyChanged", "(", "self", ",", "callback", ")", ":", "self", ".", "signalDirtyChanged", "=", "callback" ]

[ "Render", "a", "DataFrame", "to", "a", "LaTeX", "tabular", "/", "longtable", "environment", "output", "." ]

[ "def", "to_latex", "(", "self", ",", "buf", ":", "Optional", "[", "FilePathOrBuffer", "[", "str", "]", "]", "=", "None", ",", "column_format", ":", "Optional", "[", "str", "]", "=", "None", ",", "longtable", ":", "bool", "=", "False", ",", "encoding", ":", "Optional", "[", "str", "]", "=", "None", ",", "multicolumn", ":", "bool", "=", "False", ",", "multicolumn_format", ":", "Optional", "[", "str", "]", "=", "None", ",", "multirow", ":", "bool", "=", "False", ",", "caption", ":", "Optional", "[", "str", "]", "=", "None", ",", "label", ":", "Optional", "[", "str", "]", "=", "None", ",", ")", "->", "Optional", "[", "str", "]", ":", "from", "pandas", ".", "io", ".", "formats", ".", "latex", "import", "LatexFormatter", "return", "LatexFormatter", "(", "self", ",", "column_format", "=", "column_format", ",", "longtable", "=", "longtable", ",", "multicolumn", "=", "multicolumn", ",", "multicolumn_format", "=", "multicolumn_format", ",", "multirow", "=", "multirow", ",", "caption", "=", "caption", ",", "label", "=", "label", ",", ")", ".", "get_result", "(", "buf", "=", "buf", ",", "encoding", "=", "encoding", ")" ]

[ "Compute", "the", "(", "Moore", "-", "Penrose", ")", "pseudo", "-", "inverse", "of", "a", "matrix", "." ]

[ "def", "pinv2", "(", "a", ",", "cond", "=", "None", ",", "rcond", "=", "None", ",", "return_rank", "=", "False", ",", "check_finite", "=", "True", ")", ":", "a", "=", "_asarray_validated", "(", "a", ",", "check_finite", "=", "check_finite", ")", "u", ",", "s", ",", "vh", "=", "decomp_svd", ".", "svd", "(", "a", ",", "full_matrices", "=", "False", ",", "check_finite", "=", "False", ")", "if", "rcond", "is", "not", "None", ":", "cond", "=", "rcond", "if", "cond", "in", "[", "None", ",", "-", "1", "]", ":", "t", "=", "u", ".", "dtype", ".", "char", ".", "lower", "(", ")", "factor", "=", "{", "'f'", ":", "1E3", ",", "'d'", ":", "1E6", "}", "cond", "=", "factor", "[", "t", "]", "*", "np", ".", "finfo", "(", "t", ")", ".", "eps", "rank", "=", "np", ".", "sum", "(", "s", ">", "cond", "*", "np", ".", "max", "(", "s", ")", ")", "u", "=", "u", "[", ":", ",", ":", "rank", "]", "u", "/=", "s", "[", ":", "rank", "]", "B", "=", "np", ".", "transpose", "(", "np", ".", "conjugate", "(", "np", ".", "dot", "(", "u", ",", "vh", "[", ":", "rank", "]", ")", ")", ")", "if", "return_rank", ":", "return", "B", ",", "rank", "else", ":", "return", "B" ]

[ "Create", "an", "BhArray", "." ]

[ "def", "array", "(", "obj", ",", "dtype", "=", "None", ",", "copy", "=", "False", ")", ":", "if", "isinstance", "(", "obj", ",", "bharray", ".", "BhArray", ")", ":", "if", "dtype", "is", "None", ":", "dtype", "=", "obj", ".", "dtype", "return", "obj", ".", "astype", "(", "dtype", ",", "always_copy", "=", "copy", ")", "else", ":", "return", "bharray", ".", "BhArray", ".", "from_object", "(", "obj", ")" ]

[ "Check", "whether", "parallel", "environment", "variables", "have", "been", "exported", "or", "not", "." ]

[ "def", "_check_parallel_envs", "(", ")", ":", "if", "not", "GlobalComm", ".", "CHECK_ENVS", ":", "return", "import", "os", "rank_id_str", "=", "os", ".", "getenv", "(", "\"RANK_ID\"", ")", "if", "not", "rank_id_str", ":", "raise", "RuntimeError", "(", "\"Environment variables RANK_ID has not been exported, please export variables 'RANK_ID'.\"", ")", "try", ":", "int", "(", "rank_id_str", ")", "except", "ValueError", ":", "print", "(", "\"Environment variables 'RANK_ID' should be number, but got the type : {}\"", ".", "format", "(", "type", "(", "rank_id_str", ")", ")", ")", "finally", ":", "pass", "rank_table_file_str", "=", "os", ".", "getenv", "(", "\"MINDSPORE_HCCL_CONFIG_PATH\"", ")", "rank_table_file_str_old", "=", "os", ".", "getenv", "(", "\"RANK_TABLE_FILE\"", ")", "if", "not", "rank_table_file_str", "and", "not", "rank_table_file_str_old", ":", "raise", "RuntimeError", "(", "\"Get hccl rank_table_file failed, \"", "\"please export MINDSPORE_HCCL_CONFIG_PATH or RANK_TABLE_FILE.\"", ")" ]

[ "Look", "for", "VCS", "schemes", "in", "the", "URL", "." ]

[ "def", "_match_vcs_scheme", "(", "url", ")", ":", "# type: (str) -> Optional[str]", "for", "scheme", "in", "vcs", ".", "schemes", ":", "if", "url", ".", "lower", "(", ")", ".", "startswith", "(", "scheme", ")", "and", "url", "[", "len", "(", "scheme", ")", "]", "in", "'+:'", ":", "return", "scheme", "return", "None" ]

[ "Return", "the", "kind", "of", "the", "histogram", ".", "Will", "be", "one", "of", "boolean", "flag", "count", "enumerated", "linear", "or", "exponential", "." ]

[ "def", "kind", "(", "self", ")", ":", "return", "self", ".", "_kind" ]

[ "Given", "a", "node", "and", "a", "set", "of", "nodes", "this", "function", "return", "the", "extra", "size", "that", "needed", "if", "this", "node", "is", "included", "in", "this", "set", "." ]

[ "def", "get_extra_size_of", "(", "node", ":", "Node", ",", "nodes", ":", "Set", "[", "Node", "]", ")", "->", "int", ":", "# Find all its input nodes", "input_nodes", ":", "Dict", "[", "Node", ",", "None", "]", "=", "{", "}", "map_arg", "(", "node", ".", "args", ",", "lambda", "n", ":", "input_nodes", ".", "setdefault", "(", "n", ")", ")", "map_arg", "(", "node", ".", "kwargs", ",", "lambda", "n", ":", "input_nodes", ".", "setdefault", "(", "n", ")", ")", "# Calculate total size of related nodes", "total_size_of_input_nodes", "=", "0", "for", "n", "in", "input_nodes", ":", "# Make sure this node hasn't been in this set yet", "if", "n", "not", "in", "nodes", ":", "size_bytes", "=", "getattr", "(", "n", ",", "\"size_bytes\"", ",", "None", ")", "if", "size_bytes", ":", "total_size_of_input_nodes", "+=", "size_bytes", ".", "output_size", "else", ":", "raise", "RuntimeError", "(", "\"node has no size_bytes attr\"", ")", "# Don't forget the op node itself", "size_bytes", "=", "getattr", "(", "node", ",", "\"size_bytes\"", ",", "None", ")", "if", "size_bytes", ":", "total_size_of_input_nodes", "+=", "size_bytes", ".", "total_size", "else", ":", "raise", "RuntimeError", "(", "\"node has no size_bytes attr\"", ")", "return", "total_size_of_input_nodes" ]

[ "Initialize", "internal", "state", "from", "hashable", "object", "." ]

[ "def", "seed", "(", "self", ",", "a", "=", "None", ")", ":", "if", "a", "is", "None", ":", "try", ":", "a", "=", "long", "(", "_hexlify", "(", "_urandom", "(", "16", ")", ")", ",", "16", ")", "except", "NotImplementedError", ":", "import", "time", "a", "=", "long", "(", "time", ".", "time", "(", ")", "*", "256", ")", "# use fractional seconds", "if", "not", "isinstance", "(", "a", ",", "(", "int", ",", "long", ")", ")", ":", "a", "=", "hash", "(", "a", ")", "a", ",", "x", "=", "divmod", "(", "a", ",", "30268", ")", "a", ",", "y", "=", "divmod", "(", "a", ",", "30306", ")", "a", ",", "z", "=", "divmod", "(", "a", ",", "30322", ")", "self", ".", "_seed", "=", "int", "(", "x", ")", "+", "1", ",", "int", "(", "y", ")", "+", "1", ",", "int", "(", "z", ")", "+", "1", "self", ".", "gauss_next", "=", "None" ]

[ "Prints", "a", "brief", "usage", "string", "and", "exits", "optionally", "with", "an", "error", "message", "." ]

[ "def", "PrintUsage", "(", "message", ")", ":", "sys", ".", "stderr", ".", "write", "(", "_USAGE", ")", "if", "message", ":", "sys", ".", "exit", "(", "'\\nFATAL ERROR: '", "+", "message", ")", "else", ":", "sys", ".", "exit", "(", "1", ")" ]

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

[ "def", "GetColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridEvent_GetColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Estimate", "rank", "of", "a", "complex", "matrix", "to", "a", "specified", "relative", "precision", "using", "random", "matrix", "-", "vector", "multiplication", "." ]

[ "def", "idz_findrank", "(", "eps", ",", "m", ",", "n", ",", "matveca", ")", ":", "k", ",", "ra", ",", "ier", "=", "_id", ".", "idz_findrank", "(", "eps", ",", "m", ",", "n", ",", "matveca", ")", "if", "ier", ":", "raise", "_RETCODE_ERROR", "return", "k" ]

[ "__sub__", "(", "self", "RealPoint", "pt", ")", "-", ">", "RealPoint" ]

[ "def", "__sub__", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "RealPoint___sub__", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Generate", "thunk", "and", "method", "code", "for", "a", "given", "routine", "." ]

[ "def", "parse_routine", "(", "name", ",", "args", ",", "types", ")", ":", "ret_spec", "=", "args", "[", "0", "]", "arg_spec", "=", "args", "[", "1", ":", "]", "def", "get_arglist", "(", "I_type", ",", "T_type", ")", ":", "\"\"\"\n Generate argument list for calling the C++ function\n \"\"\"", "args", "=", "[", "]", "next_is_writeable", "=", "False", "j", "=", "0", "for", "t", "in", "arg_spec", ":", "const", "=", "''", "if", "next_is_writeable", "else", "'const '", "next_is_writeable", "=", "False", "if", "t", "==", "'*'", ":", "next_is_writeable", "=", "True", "continue", "elif", "t", "==", "'i'", ":", "args", ".", "append", "(", "\"*(%s*)a[%d]\"", "%", "(", "const", "+", "I_type", ",", "j", ")", ")", "elif", "t", "==", "'I'", ":", "args", ".", "append", "(", "\"(%s*)a[%d]\"", "%", "(", "const", "+", "I_type", ",", "j", ")", ")", "elif", "t", "==", "'T'", ":", "args", ".", "append", "(", "\"(%s*)a[%d]\"", "%", "(", "const", "+", "T_type", ",", "j", ")", ")", "elif", "t", "==", "'B'", ":", "args", ".", "append", "(", "\"(npy_bool_wrapper*)a[%d]\"", "%", "(", "j", ",", ")", ")", "elif", "t", "==", "'V'", ":", "if", "const", ":", "raise", "ValueError", "(", "\"'V' argument must be an output arg\"", ")", "args", ".", "append", "(", "\"(std::vector<%s>*)a[%d]\"", "%", "(", "I_type", ",", "j", ",", ")", ")", "elif", "t", "==", "'W'", ":", "if", "const", ":", "raise", "ValueError", "(", "\"'W' argument must be an output arg\"", ")", "args", ".", "append", "(", "\"(std::vector<%s>*)a[%d]\"", "%", "(", "T_type", ",", "j", ",", ")", ")", "else", ":", "raise", "ValueError", "(", "\"Invalid spec character %r\"", "%", "(", "t", ",", ")", ")", "j", "+=", "1", "return", "\", \"", ".", "join", "(", "args", ")", "# Generate thunk code: a giant switch statement with different", "# type combinations inside.", "thunk_content", "=", "\"\"\"int j = get_thunk_case(I_typenum, T_typenum);\n switch (j) {\"\"\"", "for", "j", ",", "I_typenum", ",", "T_typenum", ",", "I_type", ",", "T_type", "in", "types", ":", "arglist", "=", "get_arglist", "(", "I_type", ",", "T_type", ")", "if", "T_type", "is", "None", ":", "dispatch", "=", "\"%s\"", "%", "(", "I_type", ",", ")", "else", ":", "dispatch", "=", "\"%s,%s\"", "%", "(", "I_type", ",", "T_type", ")", "if", "'B'", "in", "arg_spec", ":", "dispatch", "+=", "\",npy_bool_wrapper\"", "piece", "=", "\"\"\"\n case %(j)s:\"\"\"", "if", "ret_spec", "==", "'v'", ":", "piece", "+=", "\"\"\"\n (void)%(name)s<%(dispatch)s>(%(arglist)s);\n return 0;\"\"\"", "else", ":", "piece", "+=", "\"\"\"\n return %(name)s<%(dispatch)s>(%(arglist)s);\"\"\"", "thunk_content", "+=", "piece", "%", "dict", "(", "j", "=", "j", ",", "I_type", "=", "I_type", ",", "T_type", "=", "T_type", ",", "I_typenum", "=", "I_typenum", ",", "T_typenum", "=", "T_typenum", ",", "arglist", "=", "arglist", ",", "name", "=", "name", ",", "dispatch", "=", "dispatch", ")", "thunk_content", "+=", "\"\"\"\n default:\n throw std::runtime_error(\"internal error: invalid argument typenums\");\n }\"\"\"", "thunk_code", "=", "THUNK_TEMPLATE", "%", "dict", "(", "name", "=", "name", ",", "thunk_content", "=", "thunk_content", ")", "# Generate method code", "method_code", "=", "METHOD_TEMPLATE", "%", "dict", "(", "name", "=", "name", ",", "ret_spec", "=", "ret_spec", ",", "arg_spec", "=", "arg_spec", ")", "return", "thunk_code", ",", "method_code" ]

[ "This", "function", "allows", "you", "to", "check", "if", "an", "IP", "belongs", "to", "a", "network", "subnet" ]

[ "def", "address_in_network", "(", "ip", ",", "net", ")", ":", "ipaddr", "=", "struct", ".", "unpack", "(", "'=L'", ",", "socket", ".", "inet_aton", "(", "ip", ")", ")", "[", "0", "]", "netaddr", ",", "bits", "=", "net", ".", "split", "(", "'/'", ")", "netmask", "=", "struct", ".", "unpack", "(", "'=L'", ",", "socket", ".", "inet_aton", "(", "dotted_netmask", "(", "int", "(", "bits", ")", ")", ")", ")", "[", "0", "]", "network", "=", "struct", ".", "unpack", "(", "'=L'", ",", "socket", ".", "inet_aton", "(", "netaddr", ")", ")", "[", "0", "]", "&", "netmask", "return", "(", "ipaddr", "&", "netmask", ")", "==", "(", "network", "&", "netmask", ")" ]

[ "Broadcasts", "a", "sequence", "tensors", "to", "the", "specified", "GPUs", ".", "Small", "tensors", "are", "first", "coalesced", "into", "a", "buffer", "to", "reduce", "the", "number", "of", "synchronizations", "." ]

[ "def", "broadcast_coalesced", "(", "tensors", ",", "devices", ",", "buffer_size", "=", "10485760", ")", ":", "devices", "=", "[", "_get_device_index", "(", "d", ")", "for", "d", "in", "devices", "]", "tensors", "=", "[", "_handle_complex", "(", "t", ")", "for", "t", "in", "tensors", "]", "return", "torch", ".", "_C", ".", "_broadcast_coalesced", "(", "tensors", ",", "devices", ",", "buffer_size", ")" ]

[ "Override", "RPCServer", "method", "for", "IDLE" ]

[ "def", "handle_error", "(", "self", ",", "request", ",", "client_address", ")", ":", "global", "quitting", "try", ":", "raise", "except", "SystemExit", ":", "raise", "except", "EOFError", ":", "global", "exit_now", "exit_now", "=", "True", "thread", ".", "interrupt_main", "(", ")", "except", ":", "erf", "=", "sys", ".", "__stderr__", "print", ">>", "erf", ",", "'\\n'", "+", "'-'", "*", "40", "print", ">>", "erf", ",", "'Unhandled server exception!'", "print", ">>", "erf", ",", "'Thread: %s'", "%", "threading", ".", "currentThread", "(", ")", ".", "getName", "(", ")", "print", ">>", "erf", ",", "'Client Address: '", ",", "client_address", "print", ">>", "erf", ",", "'Request: '", ",", "repr", "(", "request", ")", "traceback", ".", "print_exc", "(", "file", "=", "erf", ")", "print", ">>", "erf", ",", "'\\n*** Unrecoverable, server exiting!'", "print", ">>", "erf", ",", "'-'", "*", "40", "quitting", "=", "True", "thread", ".", "interrupt_main", "(", ")" ]

[ "Pull", "container", "images" ]

[ "def", "pull", "(", "ctx", ",", "c", ")", ":", "faasm_ver", "=", "get_faasm_version", "(", ")", "_check_valid_containers", "(", "c", ")", "for", "container", "in", "c", ":", "run", "(", "\"docker pull faasm/{}:{}\"", ".", "format", "(", "container", ",", "faasm_ver", ")", ",", "shell", "=", "True", ",", "check", "=", "True", ",", "cwd", "=", "PROJ_ROOT", ",", ")" ]

[ "Return", "the", "first", "or", "only", "value", "for", "specified", "attribute", "." ]

[ "def", "get_attrib", "(", "self", ",", "name", ")", ":", "if", "name", "in", "self", ".", "attribs", ":", "if", "isinstance", "(", "self", ".", "attribs", "[", "name", "]", ",", "list", ")", ":", "# the value is a list", "return", "self", ".", "attribs", "[", "name", "]", "[", "0", "]", "else", ":", "# the value is a string", "return", "self", ".", "attribs", "[", "name", "]", "return", "None" ]

[ "Return", "a", "measure", "of", "the", "sequences", "similarity", "(", "float", "in", "[", "0", "1", "]", ")", "." ]

[ "def", "ratio", "(", "self", ")", ":", "matches", "=", "reduce", "(", "lambda", "sum", ",", "triple", ":", "sum", "+", "triple", "[", "-", "1", "]", ",", "self", ".", "get_matching_blocks", "(", ")", ",", "0", ")", "return", "_calculate_ratio", "(", "matches", ",", "len", "(", "self", ".", "a", ")", "+", "len", "(", "self", ".", "b", ")", ")" ]

[ "Checks", "an", "individual", "token", "for", "lint", "warnings", "/", "errors", "." ]

[ "def", "_LintPass", "(", "self", ",", "token", ")", ":", "self", ".", "_lint_rules", ".", "CheckToken", "(", "token", ",", "self", ".", "_state_tracker", ")" ]

[ "Add", "a", "list", "of", "files", "to", "the", "manifest", "." ]

[ "def", "add_many", "(", "self", ",", "items", ")", ":", "for", "item", "in", "items", ":", "self", ".", "add", "(", "item", ")" ]

[ "Compute", "the", "LHS", "for", "the", "set", "of", "equations", "for", "a", "symmetric", "logit", "QRE", "of", "a", "symmetric", "game", "." ]

[ "def", "sym_compute_lhs", "(", "game", ",", "point", ")", ":", "profile", "=", "game", ".", "mixed_strategy_profile", "(", "point", "=", "[", "math", ".", "exp", "(", "x", ")", "for", "x", "in", "point", "[", ":", "-", "1", "]", "]", ")", "logprofile", "=", "point", "[", ":", "-", "1", "]", "lam", "=", "point", "[", "-", "1", "]", "lhs", "=", "numpy", ".", "zeros", "(", "len", "(", "profile", ")", ")", "for", "(", "st", ",", "cont", ")", "in", "enumerate", "(", "game", ".", "choices", ")", ":", "if", "st", "==", "0", ":", "# sum-to-one equation", "lhs", "[", "st", "]", "=", "-", "1.0", "+", "sum", "(", "profile", ")", "else", ":", "lhs", "[", "st", "]", "=", "(", "logprofile", "[", "st", "]", "-", "logprofile", "[", "0", "]", "-", "lam", "*", "(", "profile", ".", "strategy_value", "(", "st", ")", "-", "profile", ".", "strategy_value", "(", "0", ")", ")", ")", "return", "lhs" ]

[ "Creates", "a", "new", "default", "object", "ACL", "entry", "on", "the", "specified", "bucket", "." ]

[ "def", "RunWithArgs", "(", "self", ",", "bucket", ")", ":", "client", "=", "GetClientFromFlags", "(", ")", "global_params", "=", "GetGlobalParamsFromFlags", "(", ")", "request", "=", "messages", ".", "ObjectAccessControl", "(", "bucket", "=", "bucket", ".", "decode", "(", "'utf8'", ")", ",", ")", "if", "FLAGS", "[", "'domain'", "]", ".", "present", ":", "request", ".", "domain", "=", "FLAGS", ".", "domain", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'email'", "]", ".", "present", ":", "request", ".", "email", "=", "FLAGS", ".", "email", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'entity'", "]", ".", "present", ":", "request", ".", "entity", "=", "FLAGS", ".", "entity", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'entityId'", "]", ".", "present", ":", "request", ".", "entityId", "=", "FLAGS", ".", "entityId", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'etag'", "]", ".", "present", ":", "request", ".", "etag", "=", "FLAGS", ".", "etag", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'generation'", "]", ".", "present", ":", "request", ".", "generation", "=", "int", "(", "FLAGS", ".", "generation", ")", "if", "FLAGS", "[", "'id'", "]", ".", "present", ":", "request", ".", "id", "=", "FLAGS", ".", "id", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'kind'", "]", ".", "present", ":", "request", ".", "kind", "=", "FLAGS", ".", "kind", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'object'", "]", ".", "present", ":", "request", ".", "object", "=", "FLAGS", ".", "object", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'projectTeam'", "]", ".", "present", ":", "request", ".", "projectTeam", "=", "apitools_base", ".", "JsonToMessage", "(", "messages", ".", "ObjectAccessControl", ".", "ProjectTeamValue", ",", "FLAGS", ".", "projectTeam", ")", "if", "FLAGS", "[", "'role'", "]", ".", "present", ":", "request", ".", "role", "=", "FLAGS", ".", "role", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'selfLink'", "]", ".", "present", ":", "request", ".", "selfLink", "=", "FLAGS", ".", "selfLink", ".", "decode", "(", "'utf8'", ")", "result", "=", "client", ".", "defaultObjectAccessControls", ".", "Insert", "(", "request", ",", "global_params", "=", "global_params", ")", "print", "apitools_base_cli", ".", "FormatOutput", "(", "result", ")" ]

[ "Writes", "the", "client", "side", "destintion", "initialization", "validation", "if", "needed", "." ]

[ "def", "WriteDestinationInitalizationValidatationIfNeeded", "(", "self", ",", "file", ",", "func", ")", ":", "parts", "=", "self", ".", "type", ".", "split", "(", "\" \"", ")", "if", "len", "(", "parts", ")", ">", "1", ":", "return", "if", "parts", "[", "0", "]", "in", "self", ".", "need_validation_", ":", "file", ".", "Write", "(", "\" GPU_CLIENT_VALIDATE_DESTINATION_%sINITALIZATION(%s, %s);\\n\"", "%", "(", "\"OPTIONAL_\"", "if", "self", ".", "optional", "else", "\"\"", ",", "self", ".", "type", "[", ":", "-", "1", "]", ",", "self", ".", "name", ")", ")" ]

[ "Returns", "true", "if", "the", "message", "should", "be", "printed", "in", "the", "given", "timestamp", "otherwise", "returns", "false", ".", "The", "timestamp", "is", "in", "seconds", "granularity", ".", ":", "type", "timestamp", ":", "int", ":", "type", "message", ":", "str", ":", "rtype", ":", "bool" ]

[ "def", "shouldPrintMessage", "(", "self", ",", "timestamp", ",", "message", ")", ":", "while", "self", ".", "__dq", "and", "self", ".", "__dq", "[", "0", "]", "[", "0", "]", "<=", "timestamp", "-", "10", ":", "self", ".", "__printed", ".", "remove", "(", "self", ".", "__dq", ".", "popleft", "(", ")", "[", "1", "]", ")", "if", "message", "in", "self", ".", "__printed", ":", "return", "False", "self", ".", "__dq", ".", "append", "(", "(", "timestamp", ",", "message", ")", ")", "self", ".", "__printed", ".", "add", "(", "message", ")", "return", "True" ]

[ "This", "method", "is", "for", "introspection", ".", "Using", "dir", "(", "thispyqtclass_object", ")", "returns", "a", "list", "of", "all", "children", "methods", "properties", "and", "dynamic", "properties", "." ]

[ "def", "__members__", "(", "self", ")", ":", "names", "=", "list", "(", "self", ".", "__dict__", ".", "keys", "(", ")", ")", "for", "c", "in", "self", ".", "_instance", ".", "children", "(", ")", ":", "child_name", "=", "str", "(", "c", ".", "objectName", "(", ")", ")", "if", "child_name", ":", "names", ".", "append", "(", "child_name", ")", "for", "pn", "in", "self", ".", "_instance", ".", "dynamicPropertyNames", "(", ")", ":", "names", ".", "append", "(", "str", "(", "pn", ")", ")", "return", "names" ]

[ "Returns", "true", "for", "each", "element", "if", "the", "element", "is", "a", "titlecased", "string", "and", "there", "is", "at", "least", "one", "character", "false", "otherwise", "." ]

[ "def", "istitle", "(", "a", ")", ":", "return", "_vec_string", "(", "a", ",", "bool_", ",", "'istitle'", ")" ]

[ "Reads", "package", "blob", "info", "from", "json", "file", "." ]

[ "def", "ReadPackageBlobsJson", "(", "json_path", ")", ":", "with", "open", "(", "json_path", ",", "'rt'", ")", "as", "json_file", ":", "formatted_blob_info", "=", "json", ".", "load", "(", "json_file", ")", "package_blobs", "=", "{", "}", "for", "package", "in", "formatted_blob_info", ":", "package_blobs", "[", "package", "]", "=", "{", "}", "for", "blob_info", "in", "formatted_blob_info", "[", "package", "]", ":", "blob", "=", "Blob", "(", "name", "=", "blob_info", "[", "'path'", "]", ",", "hash", "=", "blob_info", "[", "'merkle'", "]", ",", "uncompressed", "=", "blob_info", "[", "'bytes'", "]", ",", "compressed", "=", "blob_info", "[", "'size'", "]", ",", "is_counted", "=", "blob_info", "[", "'is_counted'", "]", ")", "package_blobs", "[", "package", "]", "[", "blob", ".", "name", "]", "=", "blob", "return", "package_blobs" ]

[ "GetNormalBitmap", "(", "self", ")", "-", ">", "Bitmap" ]

[ "def", "GetNormalBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarToolBase_GetNormalBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Whether", "self", "is", "a", "prefix", "of", "rhs", "." ]

[ "def", "prefix_of", "(", "self", ",", "rhs", ")", ":", "rhs", "=", "drake", ".", "Path", "(", "rhs", ")", ".", "canonize", "(", ")", ".", "__path", "path", "=", "self", ".", "__path", "while", "len", "(", "rhs", ")", "and", "len", "(", "path", ")", "and", "path", "[", "0", "]", "==", "rhs", "[", "0", "]", ":", "rhs", "=", "rhs", "[", "1", ":", "]", "path", "=", "path", "[", "1", ":", "]", "return", "len", "(", "path", ")", "==", "0" ]

[ "Generate", "hash", "value", "for", "WebSockets", "hixie", "-", "76", "." ]

[ "def", "gen_md5", "(", "keys", ")", ":", "key1", "=", "keys", "[", "'Sec-WebSocket-Key1'", "]", "key2", "=", "keys", "[", "'Sec-WebSocket-Key2'", "]", "key3", "=", "keys", "[", "'key3'", "]", "spaces1", "=", "key1", ".", "count", "(", "\" \"", ")", "spaces2", "=", "key2", ".", "count", "(", "\" \"", ")", "num1", "=", "int", "(", "\"\"", ".", "join", "(", "[", "c", "for", "c", "in", "key1", "if", "c", ".", "isdigit", "(", ")", "]", ")", ")", "/", "spaces1", "num2", "=", "int", "(", "\"\"", ".", "join", "(", "[", "c", "for", "c", "in", "key2", "if", "c", ".", "isdigit", "(", ")", "]", ")", ")", "/", "spaces2", "return", "b2s", "(", "md5", "(", "pack", "(", "'>II8s'", ",", "int", "(", "num1", ")", ",", "int", "(", "num2", ")", ",", "key3", ")", ")", ".", "digest", "(", ")", ")" ]

[ "gets", "a", "list", "of", "columns", "available", "in", "the", "current", "table", "along", "with", "their", "types" ]

[ "def", "GetColumnNamesAndTypes", "(", "self", ",", "table", "=", "''", ",", "join", "=", "''", ",", "what", "=", "'*'", ",", "where", "=", "''", ",", "*", "*", "kwargs", ")", ":", "table", "=", "table", "or", "self", ".", "tableName", "return", "DbInfo", ".", "GetColumnNamesAndTypes", "(", "self", ".", "dbName", ",", "table", ",", "self", ".", "user", ",", "self", ".", "password", ",", "join", "=", "join", ",", "what", "=", "what", ",", "cn", "=", "self", ".", "cn", ")" ]

[ "python", "evaluation", "wrapper" ]

[ "def", "do_python_eval", "(", "self", ")", ":", "annopath", "=", "os", ".", "path", ".", "join", "(", "self", ".", "data_path", ",", "'Annotations'", ",", "'{:s}.xml'", ")", "imageset_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "data_path", ",", "'ImageSets'", ",", "'Main'", ",", "self", ".", "image_set", "+", "'.txt'", ")", "cache_dir", "=", "os", ".", "path", ".", "join", "(", "self", ".", "cache_path", ",", "self", ".", "name", ")", "aps", "=", "[", "]", "# The PASCAL VOC metric changed in 2010", "use_07_metric", "=", "True", "if", "int", "(", "self", ".", "year", ")", "<", "2010", "else", "False", "print", "(", "'VOC07 metric? '", "+", "(", "'Y'", "if", "use_07_metric", "else", "'No'", ")", ")", "for", "cls_ind", ",", "cls", "in", "enumerate", "(", "self", ".", "classes", ")", ":", "filename", "=", "self", ".", "get_result_file_template", "(", ")", ".", "format", "(", "cls", ")", "rec", ",", "prec", ",", "ap", "=", "voc_eval", "(", "filename", ",", "annopath", ",", "imageset_file", ",", "cls", ",", "cache_dir", ",", "ovthresh", "=", "0.5", ",", "use_07_metric", "=", "use_07_metric", ")", "aps", "+=", "[", "ap", "]", "print", "(", "'AP for {} = {:.4f}'", ".", "format", "(", "cls", ",", "ap", ")", ")", "print", "(", "'Mean AP = {:.4f}'", ".", "format", "(", "np", ".", "mean", "(", "aps", ")", ")", ")" ]

[ "Instantiate", "a", "new", "IPv6", "address", "object", "." ]

[ "def", "__init__", "(", "self", ",", "address", ")", ":", "# Efficient constructor from integer.", "if", "isinstance", "(", "address", ",", "_compat_int_types", ")", ":", "self", ".", "_check_int_address", "(", "address", ")", "self", ".", "_ip", "=", "address", "return", "# Constructing from a packed address", "if", "isinstance", "(", "address", ",", "bytes", ")", ":", "self", ".", "_check_packed_address", "(", "address", ",", "16", ")", "bvs", "=", "_compat_bytes_to_byte_vals", "(", "address", ")", "self", ".", "_ip", "=", "_compat_int_from_byte_vals", "(", "bvs", ",", "'big'", ")", "return", "# Assume input argument to be string or any object representation", "# which converts into a formatted IP string.", "addr_str", "=", "_compat_str", "(", "address", ")", "if", "'/'", "in", "addr_str", ":", "raise", "AddressValueError", "(", "\"Unexpected '/' in %r\"", "%", "address", ")", "self", ".", "_ip", "=", "self", ".", "_ip_int_from_string", "(", "addr_str", ")" ]

[ "Returns", "the", "commanded", "joint", "configuration", "or", "None", "if", "it", "is", "not", "sensed", "." ]

[ "def", "commandedConfiguration", "(", "self", ")", ":", "try", ":", "return", "self", ".", "inputs", "[", "'qcmd'", "]", "except", "KeyError", ":", "return", "None" ]

[ "Return", "the", "list", "of", "global", "toolset", "requirements", ".", "Those", "requirements", "will", "be", "automatically", "added", "to", "the", "requirements", "of", "any", "main", "target", "." ]

[ "def", "requirements", "(", ")", ":", "return", "__requirements" ]

[ "Visually", "debugs", "the", "gripper" ]

[ "def", "visualize", "(", "self", ")", "->", "None", ":", "from", "klampt", "import", "vis", "vis", ".", "loop", "(", "lambda", ":", "self", ".", "addToVis", "(", ")", ")" ]

[ "Helper", "function", "to", "fetch", "values", "from", "owning", "section", "." ]

[ "def", "_fetch", "(", "self", ",", "key", ")", ":", "# switch off interpolation before we try and fetch anything !", "save_interp", "=", "self", ".", "section", ".", "main", ".", "interpolation", "self", ".", "section", ".", "main", ".", "interpolation", "=", "False", "# Start at section that \"owns\" this InterpolationEngine", "current_section", "=", "self", ".", "section", "while", "True", ":", "# try the current section first", "val", "=", "current_section", ".", "get", "(", "key", ")", "if", "val", "is", "not", "None", ":", "break", "# try \"DEFAULT\" next", "val", "=", "current_section", ".", "get", "(", "'DEFAULT'", ",", "{", "}", ")", ".", "get", "(", "key", ")", "if", "val", "is", "not", "None", ":", "break", "# move up to parent and try again", "# top-level's parent is itself", "if", "current_section", ".", "parent", "is", "current_section", ":", "# reached top level, time to give up", "break", "current_section", "=", "current_section", ".", "parent", "# restore interpolation to previous value before returning", "self", ".", "section", ".", "main", ".", "interpolation", "=", "save_interp", "if", "val", "is", "None", ":", "raise", "MissingInterpolationOption", "(", "key", ")", "return", "val", ",", "current_section" ]

[ "Sets", "the", "URL", "referring", "to", "a", "robots", ".", "txt", "file", "." ]

[ "def", "set_url", "(", "self", ",", "url", ")", ":", "self", ".", "url", "=", "url", "self", ".", "host", ",", "self", ".", "path", "=", "urllib", ".", "parse", ".", "urlparse", "(", "url", ")", "[", "1", ":", "3", "]" ]

[ "__init__", "(", "self", "unsigned", "int", "initial_size", "=", "0", ")", "-", ">", "PyDataViewIndexListModel" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_dataview", ".", "PyDataViewIndexListModel_swiginit", "(", "self", ",", "_dataview", ".", "new_PyDataViewIndexListModel", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "PyDataViewIndexListModel", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "PyDataViewIndexListModel", ")" ]

[ "Clone", "of", "this", "node", "with", "an", "other", "path", "." ]

[ "def", "clone", "(", "self", ",", "path", ")", ":", "return", "Node", "(", "path", ")" ]

[ "Derived", "classes", "override", "to", "convert", "the", "importer", "node", "to", "appropriate", "ELL", "node", "(", "s", ")", "and", "insert", "into", "the", "model" ]

[ "def", "convert_node", "(", "self", ",", "conversion_parameters", ":", "typing", ".", "Mapping", "[", "str", ",", "typing", ".", "Any", "]", ")", ":", "model", "=", "conversion_parameters", "[", "\"model\"", "]", "builder", "=", "conversion_parameters", "[", "\"builder\"", "]", "lookup_table", "=", "conversion_parameters", "[", "\"lookup_table\"", "]", "input_port_elements", "=", "lookup_table", ".", "get_port_elements_for_input", "(", "self", ".", "importer_node", ")", "order", "=", "list", "(", "np", ".", "array", "(", "self", ".", "importer_node", ".", "attributes", "[", "\"order\"", "]", ")", ".", "astype", "(", "np", ".", "int", ")", ")", "# Create the reorder node", "reorder_node", "=", "builder", ".", "AddReorderDataNode", "(", "model", ",", "input_port_elements", ",", "order", ")", "# Register the mapping", "lookup_table", ".", "add_imported_ell_node", "(", "self", ".", "importer_node", ",", "reorder_node", ")", "input_port_elements", "=", "lookup_table", ".", "get_output_port_elements_for_node", "(", "reorder_node", ")" ]

[ "Abstract", "method", "which", "should", "return", "the", "value", "that", "__file__", "is", "to", "be", "set", "to", "." ]

[ "def", "get_filename", "(", "self", ",", "fullname", ")", ":", "raise", "ImportError" ]

[ "Compares", "two", "evaluation", "results", "and", "returns", "true", "if", "the", "2nd", "one", "is", "better", "." ]

[ "def", "_default_compare_fn", "(", "curr_best_eval_result", ",", "cand_eval_result", ")", ":", "default_key", "=", "metric_key", ".", "MetricKey", ".", "LOSS", "if", "not", "curr_best_eval_result", "or", "default_key", "not", "in", "curr_best_eval_result", ":", "raise", "ValueError", "(", "'curr_best_eval_result cannot be empty or no loss is found in it.'", ")", "if", "not", "cand_eval_result", "or", "default_key", "not", "in", "cand_eval_result", ":", "raise", "ValueError", "(", "'cand_eval_result cannot be empty or no loss is found in it.'", ")", "return", "curr_best_eval_result", "[", "default_key", "]", ">", "cand_eval_result", "[", "default_key", "]" ]

[ "Sets", "a", "scanner", "class", "that", "will", "be", "used", "for", "this", "type", "." ]

[ "def", "set_scanner", "(", "type", ",", "scanner", ")", ":", "if", "__debug__", ":", "from", ".", "scanner", "import", "Scanner", "assert", "isinstance", "(", "type", ",", "basestring", ")", "assert", "issubclass", "(", "scanner", ",", "Scanner", ")", "validate", "(", "type", ")", "__types", "[", "type", "]", "[", "'scanner'", "]", "=", "scanner" ]

[ "Assemble", "the", "recurrent", "core", "network", "components", "." ]

[ "def", "_core", "(", "self", ",", "core_input", ",", "core_state", ")", ":", "(", "conv_output", ",", "action_reward", ",", "goal", ")", "=", "core_input", "# Get the states", "policy_state", ",", "locale_state", "=", "core_state", "# Locale-specific pathway", "locale_input", "=", "conv_output", "locale_output", ",", "locale_state", "=", "self", ".", "_locale_pathway", "(", "(", "locale_input", ",", "goal", ")", ",", "locale_state", ")", "(", "lstm_output", ",", "heading_output", ",", "xy_output", ",", "target_xy_output", ")", "=", "locale_output", "# Policy LSTM", "policy_input", "=", "self", ".", "_locale_bottleneck", "(", "lstm_output", ")", "if", "self", ".", "_skip_connection", ":", "policy_input", "=", "tf", ".", "concat", "(", "[", "policy_input", ",", "conv_output", "]", ",", "axis", "=", "1", ")", "if", "self", ".", "_feed_action_and_reward", ":", "policy_input", "=", "tf", ".", "concat", "(", "[", "policy_input", ",", "action_reward", "]", ",", "axis", "=", "1", ")", "policy_input", "=", "tf", ".", "identity", "(", "policy_input", ",", "name", "=", "\"policy_input\"", ")", "policy_output", ",", "policy_state", "=", "self", ".", "_policy_lstm", "(", "policy_input", ",", "policy_state", ")", "core_output", "=", "(", "policy_output", ",", "heading_output", ",", "xy_output", ",", "target_xy_output", ")", "core_state_list", "=", "[", "]", "core_state_list", ".", "append", "(", "policy_state", ")", "core_state_list", ".", "append", "(", "locale_state", ")", "core_state", "=", "tuple", "(", "core_state_list", ")", "return", "core_output", ",", "core_state" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "underlying", "data", "." ]

[ "def", "nbytes", "(", "self", ")", "->", "int", ":", "rng", "=", "self", ".", "_range", "return", "getsizeof", "(", "rng", ")", "+", "sum", "(", "getsizeof", "(", "getattr", "(", "rng", ",", "attr_name", ")", ")", "for", "attr_name", "in", "[", "\"start\"", ",", "\"stop\"", ",", "\"step\"", "]", ")" ]

[ "Collapses", "strings", "and", "chars", "on", "a", "line", "to", "simple", "or", "blocks", "." ]

[ "def", "_CollapseStrings", "(", "elided", ")", ":", "if", "_RE_PATTERN_INCLUDE", ".", "match", "(", "elided", ")", ":", "return", "elided", "# Remove escaped characters first to make quote/single quote collapsing", "# basic. Things that look like escaped characters shouldn't occur", "# outside of strings and chars.", "elided", "=", "_RE_PATTERN_CLEANSE_LINE_ESCAPES", ".", "sub", "(", "''", ",", "elided", ")", "# Replace quoted strings and digit separators. Both single quotes", "# and double quotes are processed in the same loop, otherwise", "# nested quotes wouldn't work.", "collapsed", "=", "''", "while", "True", ":", "# Find the first quote character", "match", "=", "Match", "(", "r'^([^\\'\"]*)([\\'\"])(.*)$'", ",", "elided", ")", "if", "not", "match", ":", "collapsed", "+=", "elided", "break", "head", ",", "quote", ",", "tail", "=", "match", ".", "groups", "(", ")", "if", "quote", "==", "'\"'", ":", "# Collapse double quoted strings", "second_quote", "=", "tail", ".", "find", "(", "'\"'", ")", "if", "second_quote", ">=", "0", ":", "collapsed", "+=", "head", "+", "'\"\"'", "elided", "=", "tail", "[", "second_quote", "+", "1", ":", "]", "else", ":", "# Unmatched double quote, don't bother processing the rest", "# of the line since this is probably a multiline string.", "collapsed", "+=", "elided", "break", "else", ":", "# Found single quote, check nearby text to eliminate digit separators.", "#", "# There is no special handling for floating point here, because", "# the integer/fractional/exponent parts would all be parsed", "# correctly as long as there are digits on both sides of the", "# separator. So we are fine as long as we don't see something", "# like \"0.'3\" (gcc 4.9.0 will not allow this literal).", "if", "Search", "(", "r'\\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$'", ",", "head", ")", ":", "match_literal", "=", "Match", "(", "r'^((?:\\'?[0-9a-zA-Z_])*)(.*)$'", ",", "\"'\"", "+", "tail", ")", "collapsed", "+=", "head", "+", "match_literal", ".", "group", "(", "1", ")", ".", "replace", "(", "\"'\"", ",", "''", ")", "elided", "=", "match_literal", ".", "group", "(", "2", ")", "else", ":", "second_quote", "=", "tail", ".", "find", "(", "'\\''", ")", "if", "second_quote", ">=", "0", ":", "collapsed", "+=", "head", "+", "\"''\"", "elided", "=", "tail", "[", "second_quote", "+", "1", ":", "]", "else", ":", "# Unmatched single quote", "collapsed", "+=", "elided", "break", "return", "collapsed" ]

[ "Construct", "a", "new", "ProximalAdagrad", "optimizer", "." ]

[ "def", "__init__", "(", "self", ",", "learning_rate", ",", "initial_accumulator_value", "=", "0.1", ",", "l1_regularization_strength", "=", "0.0", ",", "l2_regularization_strength", "=", "0.0", ",", "use_locking", "=", "False", ",", "name", "=", "\"ProximalAdagrad\"", ")", ":", "if", "initial_accumulator_value", "<=", "0.0", ":", "raise", "ValueError", "(", "\"initial_accumulator_value must be positive: %s\"", "%", "initial_accumulator_value", ")", "super", "(", "ProximalAdagradOptimizer", ",", "self", ")", ".", "__init__", "(", "use_locking", ",", "name", ")", "self", ".", "_learning_rate", "=", "learning_rate", "self", ".", "_initial_accumulator_value", "=", "initial_accumulator_value", "self", ".", "_l1_regularization_strength", "=", "l1_regularization_strength", "self", ".", "_l2_regularization_strength", "=", "l2_regularization_strength", "# Created in Initialize.", "self", ".", "_l1_regularization_strength_tensor", "=", "None", "self", ".", "_l2_regularization_strength_tensor", "=", "None", "self", ".", "_learning_rate_tensor", "=", "None" ]

[ "int", ":", "The", "number", "of", "components", "of", "the", "texture", "." ]

[ "def", "components", "(", "self", ")", "->", "int", ":", "return", "self", ".", "_components" ]

[ "Chunk", "-", "wise", "transformation" ]

[ "def", "apply_chunks", "(", "df", ",", "func", ",", "incols", ",", "outcols", ",", "kwargs", ",", "pessimistic_nulls", ",", "chunks", ",", "blkct", "=", "None", ",", "tpb", "=", "None", ",", ")", ":", "applychunks", "=", "ApplyChunksCompiler", "(", "func", ",", "incols", ",", "outcols", ",", "kwargs", ",", "pessimistic_nulls", ",", "cache_key", "=", "None", ")", "return", "applychunks", ".", "run", "(", "df", ",", "chunks", "=", "chunks", ",", "tpb", "=", "tpb", ")" ]

[]

[ "def", "target_assign", "(", "input", ",", "matched_indices", ",", "negative_indices", "=", "None", ",", "mismatch_value", "=", "None", ",", "name", "=", "None", ")", ":", "helper", "=", "LayerHelper", "(", "'target_assign'", ",", "*", "*", "locals", "(", ")", ")", "out", "=", "helper", ".", "create_variable_for_type_inference", "(", "dtype", "=", "input", ".", "dtype", ")", "out_weight", "=", "helper", ".", "create_variable_for_type_inference", "(", "dtype", "=", "'float32'", ")", "helper", ".", "append_op", "(", "type", "=", "'target_assign'", ",", "inputs", "=", "{", "'X'", ":", "input", ",", "'MatchIndices'", ":", "matched_indices", ",", "'NegIndices'", ":", "negative_indices", "}", ",", "outputs", "=", "{", "'Out'", ":", "out", ",", "'OutWeight'", ":", "out_weight", "}", ",", "attrs", "=", "{", "'mismatch_value'", ":", "mismatch_value", "}", ")", "return", "out", ",", "out_weight" ]

[ "Do", "whatever", "it", "takes", "to", "actually", "log", "the", "specified", "logging", "record", "." ]

[ "def", "emit", "(", "self", ",", "record", ")", ":", "raise", "NotImplementedError", "(", "'emit must be implemented '", "'by Handler subclasses'", ")" ]

[ "Content", "of", "the", "response", "in", "unicode", "." ]

[ "def", "text", "(", "self", ")", ":", "# Try charset from content-type", "content", "=", "None", "encoding", "=", "self", ".", "encoding", "if", "not", "self", ".", "content", ":", "return", "str", "(", "''", ")", "# Fallback to auto-detected encoding.", "if", "self", ".", "encoding", "is", "None", ":", "encoding", "=", "self", ".", "apparent_encoding", "# Decode unicode from given encoding.", "try", ":", "content", "=", "str", "(", "self", ".", "content", ",", "encoding", ",", "errors", "=", "'replace'", ")", "except", "(", "LookupError", ",", "TypeError", ")", ":", "# A LookupError is raised if the encoding was not found which could", "# indicate a misspelling or similar mistake.", "#", "# A TypeError can be raised if encoding is None", "#", "# So we try blindly encoding.", "content", "=", "str", "(", "self", ".", "content", ",", "errors", "=", "'replace'", ")", "return", "content" ]

[ "Return", "the", "isotope", "parent", "of", "a", "given", "molecule", "." ]

[ "def", "isotope_parent", "(", "self", ",", "mol", ",", "skip_standardize", "=", "False", ")", ":", "if", "not", "skip_standardize", ":", "mol", "=", "self", ".", "standardize", "(", "mol", ")", "else", ":", "mol", "=", "copy", ".", "deepcopy", "(", "mol", ")", "# Replace isotopes with common weight", "for", "atom", "in", "mol", ".", "GetAtoms", "(", ")", ":", "atom", ".", "SetIsotope", "(", "0", ")", "return", "mol" ]

[ "Return", "the", "type", "of", "the", "item", "TAGORID", "." ]

[ "def", "type", "(", "self", ",", "tagOrId", ")", ":", "return", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'type'", ",", "tagOrId", ")", "or", "None" ]

[ "Returns", "whether", "the", "jobs", "were", "interrupted", "by", "a", "signal", "." ]

[ "def", "were_interrupted", "(", "self", ")", ":", "return", "self", ".", "job", ".", "interrupted", "(", ")" ]

[ "Overridden", "from", "cr", ".", "Command", "." ]

[ "def", "Run", "(", "self", ",", "context", ")", ":", "src_path", "=", "context", ".", "Get", "(", "'CR_SRC'", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "src_path", ")", ":", "print", "context", ".", "Substitute", "(", "'Path {CR_SRC} is not a valid client'", ")", "exit", "(", "1", ")", "# Ensure we have an output directory override ready to fill in", "# This will only be missing if we are creating a brand new output", "# directory", "build_package", "=", "cr", ".", "auto", ".", "build", "# Collect the old version (and float convert)", "old_version", "=", "context", ".", "Find", "(", "'CR_VERSION'", ")", "try", ":", "old_version", "=", "float", "(", "old_version", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "old_version", "=", "0.0", "is_new", "=", "not", "hasattr", "(", "build_package", ",", "'config'", ")", "if", "is_new", ":", "class", "FakeModule", "(", "object", ")", ":", "OVERRIDES", "=", "cr", ".", "Config", "(", "'OVERRIDES'", ")", "def", "__init__", "(", "self", ")", ":", "self", ".", "__name__", "=", "'config'", "old_version", "=", "None", "config", "=", "FakeModule", "(", ")", "setattr", "(", "build_package", ",", "'config'", ",", "config", ")", "cr", ".", "plugin", ".", "ChainModuleConfigs", "(", "config", ")", "# Force override the version", "build_package", ".", "config", ".", "OVERRIDES", ".", "Set", "(", "CR_VERSION", "=", "cr", ".", "base", ".", "client", ".", "VERSION", ")", "# Add all the variables that we always want to have", "for", "name", "in", "OUT_CONFIG_VARS", ":", "value", "=", "context", ".", "Find", "(", "name", ")", "build_package", ".", "config", ".", "OVERRIDES", "[", "name", "]", "=", "value", "# Apply the settings from the command line", "for", "setting", "in", "self", ".", "_settings", ":", "name", ",", "separator", ",", "value", "=", "setting", ".", "partition", "(", "'='", ")", "name", "=", "name", ".", "strip", "(", ")", "if", "not", "separator", ":", "value", "=", "True", "else", ":", "value", "=", "cr", ".", "Config", ".", "ParseValue", "(", "value", ".", "strip", "(", ")", ")", "build_package", ".", "config", ".", "OVERRIDES", "[", "name", "]", "=", "value", "# Run all the output directory init hooks", "for", "hook", "in", "InitHook", ".", "Plugins", "(", ")", ":", "hook", ".", "Run", "(", "context", ",", "old_version", ",", "build_package", ".", "config", ")", "# Redo activations, they might have changed", "cr", ".", "plugin", ".", "Activate", "(", "context", ")", "# Write out the new configuration, and select it as the default", "cr", ".", "base", ".", "client", ".", "WriteConfig", "(", "context", ",", "context", ".", "Get", "(", "'CR_BUILD_DIR'", ")", ",", "build_package", ".", "config", ".", "OVERRIDES", ".", "exported", ")", "# Prepare the platform in here, using the updated config", "cr", ".", "Platform", ".", "Prepare", "(", "context", ")", "cr", ".", "SelectCommand", ".", "Select", "(", "context", ")" ]

[ "Run", "checks", "that", "applies", "to", "text", "up", "to", "the", "opening", "brace", "." ]

[ "def", "CheckBegin", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "pass" ]

[ "Checks", "for", "C", "(", "++", ")", "functions", "for", "which", "a", "Caffe", "substitute", "should", "be", "used", "." ]

[ "def", "CheckCaffeAlternatives", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "for", "function", ",", "alts", "in", "caffe_alt_function_list", ":", "ix", "=", "line", ".", "find", "(", "function", "+", "'('", ")", "if", "ix", ">=", "0", "and", "(", "ix", "==", "0", "or", "(", "not", "line", "[", "ix", "-", "1", "]", ".", "isalnum", "(", ")", "and", "line", "[", "ix", "-", "1", "]", "not", "in", "(", "'_'", ",", "'.'", ",", "'>'", ")", ")", ")", ":", "disp_alts", "=", "[", "'%s(...)'", "%", "alt", "for", "alt", "in", "alts", "]", "error", "(", "filename", ",", "linenum", ",", "'caffe/alt_fn'", ",", "2", ",", "'Use Caffe function %s instead of %s(...).'", "%", "(", "' or '", ".", "join", "(", "disp_alts", ")", ",", "function", ")", ")" ]

[ "Emulates", "the", "items", "()", "method", "of", "dictionaries", "." ]

[ "def", "Dictionary", "(", "self", ")", ":", "d", "=", "self", ".", "__dict__", "[", "'__subject'", "]", ".", "Dictionary", "(", ")", ".", "copy", "(", ")", "d", ".", "update", "(", "self", ".", "__dict__", "[", "'overrides'", "]", ")", "return", "d" ]

[ "Returns", "the", "x", "data", "limits", "of", "a", "provided", "workspace", "." ]

[ "def", "x_limits_of_workspace", "(", "workspace_name", ":", "str", ",", "default_limits", ":", "tuple", "=", "(", "DEFAULT_X_LOWER", ",", "DEFAULT_X_UPPER", ")", ")", "->", "tuple", ":", "if", "workspace_name", "is", "not", "None", "and", "check_if_workspace_exist", "(", "workspace_name", ")", ":", "x_data", "=", "retrieve_ws", "(", "workspace_name", ")", ".", "dataX", "(", "0", ")", "if", "len", "(", "x_data", ")", ">", "0", ":", "x_data", ".", "sort", "(", ")", "x_lower", ",", "x_higher", "=", "x_data", "[", "0", "]", ",", "x_data", "[", "-", "1", "]", "# An offset is applied because if the x_lower is rounded up due to the precision of the Muon GUI, then some", "# data points could be missed out unintentionally. A similar issue could happen if the x_higher were rounded", "# down due to the GUI precision.", "return", "x_lower", "-", "X_OFFSET", ",", "x_higher", "+", "X_OFFSET", "return", "default_limits" ]

[ "Use", "the", "cached", "object", ".", "setattr", "to", "set", "*", "attr_name", "*", "to", "*", "value_var", "*", "but", "run", "its", "converter", "first", "." ]

[ "def", "_setattr_with_converter", "(", "attr_name", ",", "value_var", ",", "has_on_setattr", ")", ":", "return", "\"_setattr('%s', %s(%s))\"", "%", "(", "attr_name", ",", "_init_converter_pat", "%", "(", "attr_name", ",", ")", ",", "value_var", ",", ")" ]

[ "Returns", "the", "manager", "for", "this", "frame", "@return", ":", "Reference", "to", "the", "AuiMgr", "of", "this", "window" ]

[ "def", "GetFrameManager", "(", "self", ")", ":", "return", "self", ".", "_mgr" ]

[ "dreamland", "metrics", "for", "planning", "v2" ]

[ "def", "print_sim_results", "(", "self", ")", ":", "v2_results", "=", "{", "}", "# acceleration", "v2_results", "[", "\"accel\"", "]", "=", "self", ".", "lon_acceleration_analyzer", ".", "get_acceleration", "(", ")", "# deceleration", "v2_results", "[", "\"decel\"", "]", "=", "self", ".", "lon_acceleration_analyzer", ".", "get_deceleration", "(", ")", "# jerk", "v2_results", "[", "\"acc_jerk\"", "]", "=", "self", ".", "lon_acceleration_analyzer", ".", "get_acc_jerk", "(", ")", "v2_results", "[", "\"dec_jerk\"", "]", "=", "self", ".", "lon_acceleration_analyzer", ".", "get_dec_jerk", "(", ")", "# centripetal_jerk", "v2_results", "[", "\"lat_jerk\"", "]", "=", "self", ".", "lat_acceleration_analyzer", ".", "get_jerk", "(", ")", "# centripetal_accel", "v2_results", "[", "\"lat_accel\"", "]", "=", "self", ".", "lat_acceleration_analyzer", ".", "get_acceleration", "(", ")", "# frame_count", "v2_results", "[", "\"frame_count\"", "]", "=", "self", ".", "frame_count_analyzer", ".", "get", "(", ")", "# latency", "v2_results", "[", "\"planning_latency\"", "]", "=", "self", ".", "latency_analyzer", ".", "get", "(", ")", "# reference line", "v2_results", "[", "\"reference_line\"", "]", "=", "self", ".", "reference_line", ".", "get", "(", ")", "# output final reuslts", "print", "(", "json", ".", "dumps", "(", "v2_results", ")", ")" ]

[ "This", "command", "allows", "the", "authorization", "secret", "for", "a", "hierarchy", "or", "lockout", "to", "be", "changed", "using", "the", "current", "authorization", "value", "as", "the", "command", "authorization", "." ]

[ "def", "__init__", "(", "self", ",", "authHandle", "=", "TPM_HANDLE", "(", ")", ",", "newAuth", "=", "None", ")", ":", "self", ".", "authHandle", "=", "authHandle", "self", ".", "newAuth", "=", "newAuth" ]

[ "Initialise", "an", "instance", "of", "a", "SIP", "generated", "module", "Makefile", "." ]

[ "def", "__init__", "(", "self", ",", "configuration", ",", "build_file", ",", "install_dir", "=", "None", ",", "static", "=", "0", ",", "console", "=", "0", ",", "qt", "=", "0", ",", "opengl", "=", "0", ",", "threaded", "=", "0", ",", "warnings", "=", "1", ",", "debug", "=", "0", ",", "dir", "=", "None", ",", "makefile", "=", "\"Makefile\"", ",", "installs", "=", "None", ",", "strip", "=", "1", ",", "export_all", "=", "0", ",", "universal", "=", "None", ",", "arch", "=", "None", ",", "prot_is_public", "=", "0", ",", "deployment_target", "=", "None", ")", ":", "ModuleMakefile", ".", "__init__", "(", "self", ",", "configuration", ",", "build_file", ",", "install_dir", ",", "static", ",", "console", ",", "qt", ",", "opengl", ",", "threaded", ",", "warnings", ",", "debug", ",", "dir", ",", "makefile", ",", "installs", ",", "strip", ",", "export_all", ",", "universal", ",", "arch", ",", "deployment_target", ")", "self", ".", "_prot_is_public", "=", "prot_is_public" ]

[ "In", "CSV", "format", "the", "input", "is", "a", "folder", "containing", "two", "files", "X", ".", "csv", "and", "Y", ".", "csv", ".", "Each", "file", "contains", "comma", "seperated", "values", ".", "X", "contains", "feature", "vector", "and", "Y", "contains", "the", "class", "ID", "of", "each", "data", "point", "." ]

[ "def", "readXandYasCSV", "(", "trainingDataset", ")", ":", "if", "trainingDataset", "==", "True", "or", "usingTrainingDataset", "(", ")", "==", "True", ":", "X", "=", "readFileAsMat", "(", "os", ".", "path", ".", "join", "(", "Config", ".", "trainingFile", ",", "\"X.csv\"", ")", ",", "\", \"", ",", "float", ")", "Y", "=", "readFileAsMat", "(", "os", ".", "path", ".", "join", "(", "Config", ".", "trainingFile", ",", "\"Y.csv\"", ")", ",", "\", \"", ",", "int", ")", "else", ":", "X", "=", "readFileAsMat", "(", "os", ".", "path", ".", "join", "(", "Config", ".", "testingFile", ",", "\"X.csv\"", ")", ",", "\", \"", ",", "float", ")", "Y", "=", "readFileAsMat", "(", "os", ".", "path", ".", "join", "(", "Config", ".", "testingFile", ",", "\"Y.csv\"", ")", ",", "\", \"", ",", "int", ")", "Y", "=", "zeroIndexLabels", "(", "Y", ")", "return", "X", ",", "Y" ]

[ "Returns", ":", "int", ":", "The", "number", "of", ":", "class", ":", "SchemaElementDefinition", "objects", "." ]

[ "def", "numElementDefinitions", "(", "self", ")", ":", "return", "internals", ".", "blpapi_SchemaTypeDefinition_numElementDefinitions", "(", "self", ".", "__handle", ")" ]

[ "PreGauge", "()", "-", ">", "Gauge" ]

[ "def", "PreGauge", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_controls_", ".", "new_PreGauge", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Use", "the", "_winreg", "module", "to", "obtain", "the", "value", "of", "a", "registry", "key", "." ]

[ "def", "_RegistryGetValueUsingWinReg", "(", "key", ",", "value", ")", ":", "from", "winreg", "import", "HKEY_LOCAL_MACHINE", ",", "OpenKey", ",", "QueryValueEx", "try", ":", "root", ",", "subkey", "=", "key", ".", "split", "(", "\"\\\\\"", ",", "1", ")", "assert", "root", "==", "\"HKLM\"", "# Only need HKLM for now.", "with", "OpenKey", "(", "HKEY_LOCAL_MACHINE", ",", "subkey", ")", "as", "hkey", ":", "return", "QueryValueEx", "(", "hkey", ",", "value", ")", "[", "0", "]", "except", "OSError", ":", "return", "None" ]

[ "SetRange", "(", "self", "int", "range", ")" ]

[ "def", "SetRange", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "Gauge_SetRange", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "AddStretchableSpace", "(", "self", ")", "-", ">", "ToolBarToolBase" ]

[ "def", "AddStretchableSpace", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarBase_AddStretchableSpace", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "a", "custom", "OpenGL", "drawing", "function", "for", "an", "item", "." ]

[ "def", "setDrawFunc", "(", "name", ":", "ItemPath", ",", "func", ":", "Callable", ")", "->", "None", ":", "scene", "(", ")", ".", "setDrawFunc", "(", "name", ",", "func", ")" ]

[ "Pass", "in", "a", "RenderingStats", "object", "directly", ".", "For", "unittests", "that", "don", "t", "call", "Start", "/", "Stop", "." ]

[ "def", "SetStats", "(", "self", ",", "stats", ")", ":", "self", ".", "_stats", "=", "stats" ]

[ "Acquire", "a", "thread", "lock", "for", "serializing", "access", "to", "the", "underlying", "I", "/", "O", "." ]

[ "def", "createLock", "(", "self", ")", ":", "self", ".", "lock", "=", "threading", ".", "RLock", "(", ")", "_register_at_fork_reinit_lock", "(", "self", ")" ]

[ "distribute", "bots", "so", "that", "they", "don", "t", "overlap" ]

[ "def", "distribute_bots", "(", "self", ",", "num_bots", ",", "bot_type", ")", ":", "# make a number of tiles to stick bots in", "N_TILES", "=", "10", "tiles", "=", "[", "(", "r", ",", "c", ")", "for", "r", "in", "range", "(", "N_TILES", ")", "for", "c", "in", "range", "(", "N_TILES", ")", "]", "random", ".", "shuffle", "(", "tiles", ")", "bots_to_add", "=", "num_bots", "while", "bots_to_add", ">", "0", ":", "(", "r", ",", "c", ")", "=", "tiles", ".", "pop", "(", ")", "# random tile", "x", ",", "y", "=", "r", "*", "constants", ".", "XDIM", "/", "float", "(", "N_TILES", ")", ",", "c", "*", "constants", ".", "YDIM", "/", "float", "(", "N_TILES", ")", "# position within tile", "x", ",", "y", "=", "x", "+", "random", ".", "random", "(", ")", "*", "constants", ".", "XDIM", "*", "0.5", "/", "N_TILES", ",", "y", "+", "random", ".", "random", "(", ")", "*", "constants", ".", "YDIM", "*", "0.5", "/", "N_TILES", "# random offset", "if", "in_bounds", "(", "x", ",", "y", ")", ":", "agent_id", "=", "common", ".", "addObject", "(", "bot_type", ",", "OpenNero", ".", "Vector3f", "(", "x", ",", "y", ",", "0", ")", ",", "scale", "=", "OpenNero", ".", "Vector3f", "(", "1", ",", "1", ",", "1", ")", ",", "type", "=", "constants", ".", "OBJECT_TYPE_ROOMBA", ",", "collision", "=", "constants", ".", "OBJECT_TYPE_ROOMBA", ")", "self", ".", "agent_ids", ".", "append", "(", "agent_id", ")", "bots_to_add", "-=", "1", "else", ":", "pass" ]

[ "TRUE", "if", "the", "shape", "s", "ancestor", "is", "currently", "selected", "." ]

[ "def", "AncestorSelected", "(", "self", ")", ":", "if", "self", ".", "_selected", ":", "return", "True", "if", "not", "self", ".", "GetParent", "(", ")", ":", "return", "False", "return", "self", ".", "GetParent", "(", ")", ".", "AncestorSelected", "(", ")" ]

[ "Clear", "selective", "variables", "from", "internal", "namespaces", "based", "on", "a", "specified", "regular", "expression", "." ]

[ "def", "reset_selective", "(", "self", ",", "regex", "=", "None", ")", ":", "if", "regex", "is", "not", "None", ":", "try", ":", "m", "=", "re", ".", "compile", "(", "regex", ")", "except", "TypeError", ":", "raise", "TypeError", "(", "'regex must be a string or compiled pattern'", ")", "# Search for keys in each namespace that match the given regex", "# If a match is found, delete the key/value pair.", "for", "ns", "in", "self", ".", "all_ns_refs", ":", "for", "var", "in", "ns", ":", "if", "m", ".", "search", "(", "var", ")", ":", "del", "ns", "[", "var", "]" ]

[ ":", "type", "points", ":", "List", "[", "List", "[", "int", "]]", ":", "type", "r", ":", "int", ":", "rtype", ":", "int" ]

[ "def", "numPoints", "(", "self", ",", "points", ",", "r", ")", ":", "def", "count_points", "(", "points", ",", "r", ",", "i", ")", ":", "angles", "=", "[", "]", "for", "j", "in", "xrange", "(", "len", "(", "points", ")", ")", ":", "if", "i", "==", "j", ":", "continue", "dx", ",", "dy", "=", "points", "[", "i", "]", "[", "0", "]", "-", "points", "[", "j", "]", "[", "0", "]", ",", "points", "[", "i", "]", "[", "1", "]", "-", "points", "[", "j", "]", "[", "1", "]", "d", "=", "math", ".", "sqrt", "(", "dx", "**", "2", "+", "dy", "**", "2", ")", "if", "d", ">", "2", "*", "r", ":", "continue", "delta", ",", "angle", "=", "math", ".", "acos", "(", "d", "/", "(", "2", "*", "r", ")", ")", ",", "math", ".", "atan2", "(", "dy", ",", "dx", ")", "angles", ".", "append", "(", "(", "angle", "-", "delta", ",", "0", ")", ")", ",", "angles", ".", "append", "(", "(", "angle", "+", "delta", ",", "1", ")", ")", "angles", ".", "sort", "(", ")", "result", ",", "count", "=", "1", ",", "1", "for", "_", ",", "is_closed", "in", "angles", ":", "# angle sweep", "if", "not", "is_closed", ":", "count", "+=", "1", "else", ":", "count", "-=", "1", "result", "=", "max", "(", "result", ",", "count", ")", "return", "result", "return", "max", "(", "count_points", "(", "points", ",", "r", ",", "i", ")", "for", "i", "in", "xrange", "(", "len", "(", "points", ")", ")", ")" ]

[ "This", "command", "is", "used", "to", "load", "an", "object", "that", "is", "not", "a", "Protected", "Object", "into", "the", "TPM", ".", "The", "command", "allows", "loading", "of", "a", "public", "area", "or", "both", "a", "public", "and", "sensitive", "area", "." ]

[ "def", "LoadExternal", "(", "self", ",", "inPrivate", ",", "inPublic", ",", "hierarchy", ")", ":", "req", "=", "TPM2_LoadExternal_REQUEST", "(", "inPrivate", ",", "inPublic", ",", "hierarchy", ")", "respBuf", "=", "self", ".", "dispatchCommand", "(", "TPM_CC", ".", "LoadExternal", ",", "req", ")", "res", "=", "self", ".", "processResponse", "(", "respBuf", ",", "LoadExternalResponse", ")", "return", "res", ".", "handle", "if", "res", "else", "None" ]

[ "Writes", "a", "variable", "definition", "with", "a", "mapping", "table", "to", "file", "intlData", "." ]

[ "def", "writeMappingsVar", "(", "intlData", ",", "dict", ",", "name", ",", "description", ",", "fileDate", ",", "url", ")", ":", "intlData", ".", "write", "(", "\"\\n\"", ")", "intlData", ".", "write", "(", "\"// {0}.\\n\"", ".", "format", "(", "description", ")", ")", "intlData", ".", "write", "(", "\"// Derived from IANA Language Subtag Registry, file date {0}.\\n\"", ".", "format", "(", "fileDate", ")", ")", "intlData", ".", "write", "(", "\"// {0}\\n\"", ".", "format", "(", "url", ")", ")", "intlData", ".", "write", "(", "\"var {0} = {{\\n\"", ".", "format", "(", "name", ")", ")", "keys", "=", "sorted", "(", "dict", ")", "for", "key", "in", "keys", ":", "if", "isinstance", "(", "dict", "[", "key", "]", ",", "basestring", ")", ":", "value", "=", "'\"{0}\"'", ".", "format", "(", "dict", "[", "key", "]", ")", "else", ":", "preferred", "=", "dict", "[", "key", "]", "[", "\"preferred\"", "]", "prefix", "=", "dict", "[", "key", "]", "[", "\"prefix\"", "]", "value", "=", "'{{preferred: \"{0}\", prefix: \"{1}\"}}'", ".", "format", "(", "preferred", ",", "prefix", ")", "intlData", ".", "write", "(", "' \"{0}\": {1},\\n'", ".", "format", "(", "key", ",", "value", ")", ")", "intlData", ".", "write", "(", "\"};\\n\"", ")" ]

[ "Take", "first", "4", "bytes", "of", "the", "Dex", "signature", "as", "Dex", "Id" ]

[ "def", "parse_dex_id", "(", "signature", ")", ":", "return", "struct", ".", "unpack", "(", "\"<I\"", ",", "signature", "[", "0", ":", "4", "]", ")", "[", "0", "]" ]