Datasets:

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Set", "certificate", "bundle", "file", "(", ".", "pem", ")", "path", "for", "ssl", "/", "tls", "host", "authentication", ".", "If", "library", "is", "built", "against", "default", "ssl", "/", "tls", "library", "the", "default", "certificate", "store", "should", "be", "used", ".", "If", "not", "(", "a", "connection", "error", "is", "returned", ")", "you", "ll", "have", "to", "provide", "a", "certificate", "bundle", "to", "the", "connection", "libraries", ".", "def", "set_certificate_bundle_path", "(", "path", ")", ";", "path", "::", "str", "::", "path", "to", "the", "certificate", "bundle", "file", "(", ".", "pem", ")", "returns", "-", ">", "None", "throws", "-", ">", "LibraryNotLoaded", "CLibException" ]

[ "def", "set_certificate_bundle_path", "(", "path", ")", ":", "clib", ".", "set_str", "(", "'SetCertificateBundlePath_ABI'", ",", "path", ")" ]

[ "dobj", "=", "obj_df", "(", "x", "project", ")", "Objective", "Function", "Gradients", "SU2", "Project", "interface", "to", "scipy", ".", "fmin_slsqp", "su2", ":", "df", "(", "x", ")", "list", "[", "nobj", "x", "dim", "]", "scipy_slsqp", ":", "df", "(", "x", ")", "ndarray", "[", "dim", "]" ]

[ "def", "obj_df", "(", "x", ",", "project", ")", ":", "dobj_list", "=", "project", ".", "obj_df", "(", "x", ")", "dobj", "=", "[", "0.0", "]", "*", "len", "(", "dobj_list", "[", "0", "]", ")", "for", "this_dobj", "in", "dobj_list", ":", "idv", "=", "0", "for", "this_dv_dobj", "in", "this_dobj", ":", "dobj", "[", "idv", "]", "=", "dobj", "[", "idv", "]", "+", "this_dv_dobj", "idv", "+=", "1", "dobj", "=", "array", "(", "dobj", ")", "return", "dobj" ]

[ "Perform", "the", "actual", "deserialization", "from", "response", "string", "to", "Python", "object", "." ]

[ "def", "deserialize", "(", "self", ",", "content", ")", ":", "_abstract", "(", ")" ]

[ "Prints", "out", "a", "debug", "message", "whenever", "the", "person", "s", "age", "changes", "." ]

[ "def", "debug_print", "(", "self", ",", "change", ")", ":", "if", "self", ".", "debug", ":", "templ", "=", "\"{first} {last} is {age} years old.\"", "s", "=", "templ", ".", "format", "(", "first", "=", "self", ".", "first_name", ",", "last", "=", "self", ".", "last_name", ",", "age", "=", "self", ".", "age", ",", ")", "print", "(", "s", ")" ]

[ "Helper", "method", "for", "static", "analysis", "." ]

[ "def", "try_iter_content", "(", "types", ",", "depth", "=", "0", ")", ":", "if", "depth", ">", "10", ":", "# It's possible that a loop has references on itself (especially with", "# CompiledObject). Therefore don't loop infinitely.", "return", "for", "typ", "in", "types", ":", "try", ":", "f", "=", "typ", ".", "py__iter__", "except", "AttributeError", ":", "pass", "else", ":", "for", "lazy_context", "in", "f", "(", ")", ":", "try_iter_content", "(", "lazy_context", ".", "infer", "(", ")", ",", "depth", "+", "1", ")" ]

[ "SetWeeks", "(", "self", "int", "n", ")", "-", ">", "DateSpan" ]

[ "def", "SetWeeks", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DateSpan_SetWeeks", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "information", "about", "the", "specified", "activity", "type", ".", "This", "includes", "configuration", "settings", "provided", "at", "registration", "time", "as", "well", "as", "other", "general", "information", "about", "the", "type", "." ]

[ "def", "describe_activity_type", "(", "self", ",", "domain", ",", "activity_name", ",", "activity_version", ")", ":", "return", "self", ".", "json_request", "(", "'DescribeActivityType'", ",", "{", "'domain'", ":", "domain", ",", "'activityType'", ":", "{", "'name'", ":", "activity_name", ",", "'version'", ":", "activity_version", "}", "}", ")" ]

[ "DoGetSize", "()", "-", ">", "(", "width", "height", ")" ]

[ "def", "DoGetSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_wizard", ".", "PyWizardPage_DoGetSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "this", "comment", "s", "target", "token", "." ]

[ "def", "GetTargetToken", "(", "self", ")", ":", "# File overviews describe the file, not a token.", "if", "self", ".", "HasFlag", "(", "'fileoverview'", ")", ":", "return", "skip_types", "=", "frozenset", "(", "[", "Type", ".", "WHITESPACE", ",", "Type", ".", "BLANK_LINE", ",", "Type", ".", "START_PAREN", "]", ")", "target_types", "=", "frozenset", "(", "[", "Type", ".", "FUNCTION_NAME", ",", "Type", ".", "IDENTIFIER", ",", "Type", ".", "SIMPLE_LVALUE", "]", ")", "token", "=", "self", ".", "end_token", ".", "next", "while", "token", ":", "if", "token", ".", "type", "in", "target_types", ":", "return", "token", "# Handles the case of a comment on \"var foo = ...'", "if", "token", ".", "IsKeyword", "(", "'var'", ")", ":", "next_code_token", "=", "tokenutil", ".", "CustomSearch", "(", "token", ",", "lambda", "t", ":", "t", ".", "type", "not", "in", "Type", ".", "NON_CODE_TYPES", ")", "if", "(", "next_code_token", "and", "next_code_token", ".", "IsType", "(", "Type", ".", "SIMPLE_LVALUE", ")", ")", ":", "return", "next_code_token", "return", "# Handles the case of a comment on \"function foo () {}\"", "if", "token", ".", "type", "is", "Type", ".", "FUNCTION_DECLARATION", ":", "next_code_token", "=", "tokenutil", ".", "CustomSearch", "(", "token", ",", "lambda", "t", ":", "t", ".", "type", "not", "in", "Type", ".", "NON_CODE_TYPES", ")", "if", "next_code_token", ".", "IsType", "(", "Type", ".", "FUNCTION_NAME", ")", ":", "return", "next_code_token", "return", "# Skip types will end the search.", "if", "token", ".", "type", "not", "in", "skip_types", ":", "return", "token", "=", "token", ".", "next" ]

[ "Returns", "true", "if", "the", "given", "line", "is", "blank", "." ]

[ "def", "IsBlankLine", "(", "line", ")", ":", "return", "not", "line", "or", "line", ".", "isspace", "(", ")" ]

[ "Ellipsis", ":", "ELLIPSIS" ]

[ "def", "p_Ellipsis", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "True" ]

[ "Create", "a", "part", "from", "a", "Request", "Field", "generated", "by", "urllib3", "." ]

[ "def", "from_field", "(", "cls", ",", "field", ",", "encoding", ")", ":", "headers", "=", "encode_with", "(", "field", ".", "render_headers", "(", ")", ",", "encoding", ")", "body", "=", "coerce_data", "(", "field", ".", "data", ",", "encoding", ")", "return", "cls", "(", "headers", ",", "body", ")" ]

[ "convert", "directory", "arg", "to", "absolute", "path", "and", "check", "that", "it", "exists" ]

[ "def", "validateFixExistingDirArg", "(", "argDir", ",", "label", ")", ":", "return", "_validateFixArgHelper", "(", "argDir", ",", "label", ",", "os", ".", "path", ".", "isdir", ")" ]

[ "Get", "parsed", "args", "." ]

[ "def", "args", "(", "self", ")", ":", "if", "self", ".", "_args", "is", "None", ":", "self", ".", "_args", "=", "self", ".", "parser", ".", "parse_args", "(", ")", "return", "self", ".", "_args" ]

[ "r", "SetMetadata", "(", "MajorObject", "self", "char", "**", "papszMetadata", "char", "const", "*", "pszDomain", "=", ")", "-", ">", "CPLErr", "SetMetadata", "(", "MajorObject", "self", "char", "*", "pszMetadataString", "char", "const", "*", "pszDomain", "=", ")", "-", ">", "CPLErr" ]

[ "def", "SetMetadata", "(", "self", ",", "*", "args", ")", ":", "return", "_ogr", ".", "MajorObject_SetMetadata", "(", "self", ",", "*", "args", ")" ]

[ "The", "AI", "has", "created", "this", "object", "so", "we", "send", "it", "s", "distributed", "object", "ID", "over", "to", "the", "client", ".", "That", "way", "the", "client", "can", "actually", "grab", "the", "object", "and", "use", "it", "to", "communicate", "with", "the", "AI", ".", "Alternatively", "store", "it", "in", "the", "Client", "Repository", "in", "self", ".", "cr" ]

[ "def", "announceGenerate", "(", "self", ")", ":", "base", ".", "messenger", ".", "send", "(", "self", ".", "cr", ".", "uniqueName", "(", "'AIDGameObjectGenerated'", ")", ",", "[", "self", ".", "doId", "]", ")", "# call the base class method", "DistributedObject", ".", "announceGenerate", "(", "self", ")" ]

[ "Handles", "result", "processing", "." ]

[ "def", "__ProcessResult", "(", "self", ",", "result", ")", ":", "if", "result", "[", "'status'", "]", ":", "self", ".", "__success_count", "+=", "1", "for", "k", ",", "v", "in", "result", "[", "'edits'", "]", ".", "iteritems", "(", ")", ":", "self", ".", "__edits", "[", "k", "]", ".", "extend", "(", "v", ")", "else", ":", "self", ".", "__failed_count", "+=", "1", "sys", ".", "stdout", ".", "write", "(", "'\\nFailed to process %s\\n'", "%", "result", "[", "'filename'", "]", ")", "sys", ".", "stdout", ".", "write", "(", "result", "[", "'stderr'", "]", ")", "sys", ".", "stdout", ".", "write", "(", "'\\n'", ")", "percentage", "=", "(", "float", "(", "self", ".", "__success_count", "+", "self", ".", "__failed_count", ")", "/", "len", "(", "self", ".", "__filenames", ")", ")", "*", "100", "sys", ".", "stdout", ".", "write", "(", "'Succeeded: %d, Failed: %d [%.2f%%]\\r'", "%", "(", "self", ".", "__success_count", ",", "self", ".", "__failed_count", ",", "percentage", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")" ]

[ "Return", "filenames", "for", "package", "s", "data", "files", "in", "src_dir" ]

[ "def", "find_data_files", "(", "self", ",", "package", ",", "src_dir", ")", ":", "globs", "=", "(", "self", ".", "package_data", ".", "get", "(", "''", ",", "[", "]", ")", "+", "self", ".", "package_data", ".", "get", "(", "package", ",", "[", "]", ")", ")", "files", "=", "[", "]", "for", "pattern", "in", "globs", ":", "# Each pattern has to be converted to a platform-specific path", "filelist", "=", "glob", "(", "os", ".", "path", ".", "join", "(", "src_dir", ",", "convert_path", "(", "pattern", ")", ")", ")", "# Files that match more than one pattern are only added once", "files", ".", "extend", "(", "[", "fn", "for", "fn", "in", "filelist", "if", "fn", "not", "in", "files", "]", ")", "return", "files" ]

[ "Sets", "up", "the", "PDB", "dependencies", "for", "a", "pch", "file", "and", "adds", "the", "object", "file", "target", "." ]

[ "def", "pch_emitter", "(", "target", ",", "source", ",", "env", ")", ":", "validate_vars", "(", "env", ")", "pch", "=", "None", "obj", "=", "None", "for", "t", "in", "target", ":", "if", "SCons", ".", "Util", ".", "splitext", "(", "str", "(", "t", ")", ")", "[", "1", "]", "==", "'.pch'", ":", "pch", "=", "t", "if", "SCons", ".", "Util", ".", "splitext", "(", "str", "(", "t", ")", ")", "[", "1", "]", "==", "'.obj'", ":", "obj", "=", "t", "if", "not", "obj", ":", "obj", "=", "SCons", ".", "Util", ".", "splitext", "(", "str", "(", "pch", ")", ")", "[", "0", "]", "+", "'.obj'", "target", "=", "[", "pch", ",", "obj", "]", "# pch must be first, and obj second for the PCHCOM to work", "if", "'PDB'", "in", "env", "and", "env", "[", "'PDB'", "]", ":", "env", ".", "SideEffect", "(", "env", "[", "'PDB'", "]", ",", "target", ")", "env", ".", "Precious", "(", "env", "[", "'PDB'", "]", ")", "return", "(", "target", ",", "source", ")" ]

[ "__init__", "(", "self", "Window", "win", "=", "None", ")", "-", ">", "WindowCreateEvent" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_core_", ".", "WindowCreateEvent_swiginit", "(", "self", ",", "_core_", ".", "new_WindowCreateEvent", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Default", "function", "for", "end", "of", "list", "test", "takes", "an", "SBValue", "object", "." ]

[ "def", "__eol_test__", "(", "val", ")", ":", "if", "not", "val", "or", "val", ".", "GetValueAsUnsigned", "(", ")", "==", "0", ":", "return", "True", "else", ":", "return", "False" ]

[ "SetErrorFileHandle", "(", "SBDebugger", "self", "FILE", "*", "f", "bool", "transfer_ownership", ")" ]

[ "def", "SetErrorFileHandle", "(", "self", ",", "f", ",", "transfer_ownership", ")", ":", "return", "_lldb", ".", "SBDebugger_SetErrorFileHandle", "(", "self", ",", "f", ",", "transfer_ownership", ")" ]

[ "Initializes", "a", "ReaderSource", "." ]

[ "def", "__init__", "(", "self", ",", "reader_cls", ",", "work_units", ",", "reader_kwargs", "=", "None", ",", "enqueue_size", "=", "None", ",", "batch_size", "=", "1", ",", "queue_capacity", "=", "None", ",", "shuffle", "=", "False", ",", "min_after_dequeue", "=", "None", ",", "num_threads", "=", "1", ",", "seed", "=", "None", ")", ":", "super", "(", "ReaderSource", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "_reader_cls", "=", "reader_cls", "self", ".", "_reader_kwargs", "=", "reader_kwargs", "self", ".", "_work_units", "=", "work_units", "self", ".", "_reader_kwargs", "=", "{", "}", "if", "reader_kwargs", "is", "None", "else", "reader_kwargs", "if", "enqueue_size", "is", "None", ":", "enqueue_size", "=", "max", "(", "1", ",", "int", "(", "batch_size", "/", "num_threads", ")", ")", "self", ".", "_enqueue_size", "=", "enqueue_size", "self", ".", "_batch_size", "=", "batch_size", "self", ".", "_queue_capacity", "=", "(", "batch_size", "*", "10", "if", "queue_capacity", "is", "None", "else", "queue_capacity", ")", "self", ".", "_shuffle", "=", "shuffle", "self", ".", "_min_after_dequeue", "=", "int", "(", "self", ".", "queue_capacity", "/", "4", "if", "min_after_dequeue", "is", "None", "else", "min_after_dequeue", ")", "self", ".", "_num_threads", "=", "num_threads", "self", ".", "_seed", "=", "seed" ]

[ "Given", "the", "header", "name", "and", "the", "value", "from", "the", "model", "return", "the", "value", "to", "be", "returned", "to", "the", "application", "program", "that", "is", "requesting", "that", "header", ".", "The", "value", "passed", "in", "by", "the", "email", "package", "may", "contain", "surrogateescaped", "binary", "data", "if", "the", "lines", "were", "parsed", "by", "a", "BytesParser", ".", "The", "returned", "value", "should", "not", "contain", "any", "surrogateescaped", "data", "." ]

[ "def", "header_fetch_parse", "(", "self", ",", "name", ",", "value", ")", ":", "raise", "NotImplementedError" ]

[ "Return", "True", "if", "two", "matrices", "perform", "same", "transformation", "." ]

[ "def", "is_same_transform", "(", "matrix0", ",", "matrix1", ")", ":", "matrix0", "=", "numpy", ".", "array", "(", "matrix0", ",", "dtype", "=", "numpy", ".", "float64", ",", "copy", "=", "True", ")", "matrix0", "/=", "matrix0", "[", "3", ",", "3", "]", "matrix1", "=", "numpy", ".", "array", "(", "matrix1", ",", "dtype", "=", "numpy", ".", "float64", ",", "copy", "=", "True", ")", "matrix1", "/=", "matrix1", "[", "3", ",", "3", "]", "return", "numpy", ".", "allclose", "(", "matrix0", ",", "matrix1", ")" ]

[ "Get", "available", "GPUs", "according", "to", "utilization", "thresholds", "." ]

[ "def", "_get_free_gpu", "(", "max_gpu_utilization", "=", "40", ",", "min_free_memory", "=", "0.5", ",", "num_gpu", "=", "1", ")", ":", "def", "get_gpu_info", "(", ")", ":", "# Get the gpu information", "gpu_info", "=", "subprocess", ".", "check_output", "(", "[", "\"nvidia-smi\"", ",", "\"--format=csv,noheader,nounits\"", ",", "\"--query-gpu=index,memory.total,memory.free,memory.used,utilization.gpu\"", "]", ")", ".", "decode", "(", ")", "gpu_info", "=", "gpu_info", ".", "split", "(", "'\\n'", ")", "gpu_info_array", "=", "[", "]", "# Check each gpu", "for", "line", "in", "gpu_info", ":", "if", "len", "(", "line", ")", ">", "0", ":", "gpu_id", ",", "total_memory", ",", "free_memory", ",", "used_memory", ",", "gpu_util", "=", "line", ".", "split", "(", "','", ")", "gpu_memory_util", "=", "float", "(", "used_memory", ")", "/", "float", "(", "total_memory", ")", "gpu_info_array", ".", "append", "(", "(", "float", "(", "gpu_util", ")", ",", "gpu_memory_util", ",", "gpu_id", ")", ")", "return", "(", "gpu_info_array", ")", "# Read the gpu information multiple times", "num_times_to_average", "=", "5", "current_array", "=", "[", "]", "for", "ind", "in", "range", "(", "num_times_to_average", ")", ":", "current_array", ".", "append", "(", "get_gpu_info", "(", ")", ")", "time", ".", "sleep", "(", "1", ")", "# Get number of gpus", "num_gpus", "=", "len", "(", "current_array", "[", "0", "]", ")", "# Average the gpu information", "avg_array", "=", "[", "(", "0", ",", "0", ",", "str", "(", "x", ")", ")", "for", "x", "in", "range", "(", "num_gpus", ")", "]", "for", "ind", "in", "range", "(", "num_times_to_average", ")", ":", "for", "gpu_ind", "in", "range", "(", "num_gpus", ")", ":", "avg_array", "[", "gpu_ind", "]", "=", "(", "avg_array", "[", "gpu_ind", "]", "[", "0", "]", "+", "current_array", "[", "ind", "]", "[", "gpu_ind", "]", "[", "0", "]", ",", "avg_array", "[", "gpu_ind", "]", "[", "1", "]", "+", "current_array", "[", "ind", "]", "[", "gpu_ind", "]", "[", "1", "]", ",", "avg_array", "[", "gpu_ind", "]", "[", "2", "]", ")", "for", "gpu_ind", "in", "range", "(", "num_gpus", ")", ":", "avg_array", "[", "gpu_ind", "]", "=", "(", "float", "(", "avg_array", "[", "gpu_ind", "]", "[", "0", "]", ")", "/", "num_times_to_average", ",", "float", "(", "avg_array", "[", "gpu_ind", "]", "[", "1", "]", ")", "/", "num_times_to_average", ",", "avg_array", "[", "gpu_ind", "]", "[", "2", "]", ")", "avg_array", ".", "sort", "(", ")", "gpus_found", "=", "0", "gpus_to_use", "=", "\"\"", "free_memory", "=", "1.0", "# Return the least utilized GPUs if it's utilized less than max_gpu_utilization and amount of free memory is at least min_free_memory", "# Otherwise, run in cpu only mode", "for", "current_gpu", "in", "avg_array", ":", "if", "current_gpu", "[", "0", "]", "<", "max_gpu_utilization", "and", "(", "1", "-", "current_gpu", "[", "1", "]", ")", ">", "min_free_memory", ":", "if", "gpus_found", "==", "0", ":", "gpus_to_use", "=", "current_gpu", "[", "2", "]", "free_memory", "=", "1", "-", "current_gpu", "[", "1", "]", "else", ":", "gpus_to_use", "=", "gpus_to_use", "+", "\",\"", "+", "current_gpu", "[", "2", "]", "free_memory", "=", "min", "(", "free_memory", ",", "1", "-", "current_gpu", "[", "1", "]", ")", "gpus_found", "=", "gpus_found", "+", "1", "if", "gpus_found", "==", "num_gpu", ":", "break", "return", "gpus_to_use", ",", "free_memory" ]

[ "If", "Categorical", ".", "argsort", "is", "called", "via", "the", "numpy", "library", "the", "first", "parameter", "in", "its", "signature", "is", "axis", "which", "takes", "either", "an", "integer", "or", "None", "so", "check", "if", "the", "ascending", "parameter", "has", "either", "integer", "type", "or", "is", "None", "since", "ascending", "itself", "should", "be", "a", "boolean" ]

[ "def", "validate_argsort_with_ascending", "(", "ascending", ",", "args", ",", "kwargs", ")", ":", "if", "is_integer", "(", "ascending", ")", "or", "ascending", "is", "None", ":", "args", "=", "(", "ascending", ",", ")", "+", "args", "ascending", "=", "True", "validate_argsort_kind", "(", "args", ",", "kwargs", ",", "max_fname_arg_count", "=", "3", ")", "return", "ascending" ]

[ "get", "all", "the", "tensors", "which", "are", "input", "or", "output", "of", "an", "op", "in", "the", "graph", "." ]

[ "def", "get_tensors", "(", "graph", ")", ":", "if", "not", "isinstance", "(", "graph", ",", "tf_ops", ".", "Graph", ")", ":", "raise", "TypeError", "(", "\"Expected a graph, got: {}\"", ".", "format", "(", "type", "(", "graph", ")", ")", ")", "ts", "=", "[", "]", "for", "op", "in", "graph", ".", "get_operations", "(", ")", ":", "concatenate_unique", "(", "ts", ",", "op", ".", "inputs", ")", "concatenate_unique", "(", "ts", ",", "op", ".", "outputs", ")", "return", "ts" ]

[ "Creates", "a", "new", "GraphModule", "consisting", "of", "the", "graph", "of", "C", "with", "the", "meaningful", "nodes", "of", "A", "shadowing", "the", "corresponding", "nodes", "of", "B", ".", "For", "example" ]

[ "def", "create_a_shadows_b", "(", "name_a", ":", "str", ",", "gm_a", ":", "GraphModule", ",", "name_b", ":", "str", ",", "gm_b", ":", "GraphModule", ",", "matched_subgraph_pairs", ":", "Dict", "[", "str", ",", "Tuple", "[", "NSSubgraph", ",", "NSSubgraph", "]", "]", ",", "logger_cls", ":", "Callable", ",", "should_log_inputs", ":", "bool", ",", "node_type_to_io_type_map", ":", "Optional", "[", "Dict", "[", "str", ",", "Set", "[", "NSNodeTargetType", "]", "]", "]", "=", "None", ",", ")", "->", "GraphModule", ":", "if", "node_type_to_io_type_map", "is", "None", ":", "node_type_to_io_type_map", "=", "get_node_type_to_io_type_map", "(", ")", "# graph_c is the graph created from copying the nodes of graph_b and inserting", "# the shadows with the nodes copied from graph_a", "graph_c", "=", "Graph", "(", ")", "env_c", ":", "Dict", "[", "str", ",", "Any", "]", "=", "{", "}", "modules", "=", "dict", "(", "gm_b", ".", "named_modules", "(", ")", ")", "def", "load_arg", "(", "a", ")", ":", "return", "map_arg", "(", "a", ",", "lambda", "node", ":", "env_c", "[", "node", ".", "name", "]", ")", "start_node_b_to_matched_subgraph_a_and_name", "=", "{", "}", "end_node_b_to_matched_subgraph_a_and_name", "=", "{", "}", "for", "match_name", ",", "match", "in", "matched_subgraph_pairs", ".", "items", "(", ")", ":", "subgraph_a", ",", "subgraph_b", "=", "match", "ref_node_type_a", "=", "get_target_type_str", "(", "subgraph_a", ".", "base_op_node", ",", "gm_a", ")", "ref_node_type_b", "=", "get_target_type_str", "(", "subgraph_b", ".", "base_op_node", ",", "gm_b", ")", "start_node_b_to_matched_subgraph_a_and_name", "[", "subgraph_b", ".", "start_node", "]", "=", "(", "subgraph_a", ",", "match_name", ",", "ref_node_type_a", ",", "ref_node_type_b", ")", "end_node_b_to_matched_subgraph_a_and_name", "[", "subgraph_b", ".", "end_node", "]", "=", "(", "subgraph_a", ",", "match_name", ",", "ref_node_type_a", ",", "ref_node_type_b", ")", "for", "node_b", "in", "gm_b", ".", "graph", ".", "nodes", ":", "if", "node_b", ".", "op", "==", "'output'", ":", "graph_c", ".", "output", "(", "map_arg", "(", "node_b", ".", "args", "[", "0", "]", ",", "load_arg", ")", ")", "continue", "# calculate the flags to determine what to do with this node", "node_b_is_start_node", "=", "node_b", "in", "start_node_b_to_matched_subgraph_a_and_name", "node_b_is_end_node", "=", "node_b", "in", "end_node_b_to_matched_subgraph_a_and_name", "if", "(", "node_b_is_start_node", "or", "node_b_is_end_node", ")", ":", "if", "node_b_is_start_node", ":", "subgraph_a", ",", "ref_name", ",", "ref_node_type_a", ",", "ref_node_type_b", "=", "start_node_b_to_matched_subgraph_a_and_name", "[", "node_b", "]", "else", ":", "assert", "node_b_is_end_node", "subgraph_a", ",", "ref_name", ",", "ref_node_type_a", ",", "ref_node_type_b", "=", "end_node_b_to_matched_subgraph_a_and_name", "[", "node_b", "]", "# For both start_node and end_node verify that we know how to do", "# the dtype cast. If we do not, skip.", "node_input_type_a", ",", "node_output_type_a", "=", "get_node_first_input_and_output_type", "(", "subgraph_a", ".", "start_node", ",", "gm_a", ",", "logger_cls", ",", "node_type_to_io_type_map", ")", "node_input_type_b", ",", "node_output_type_b", "=", "get_node_first_input_and_output_type", "(", "node_b", ",", "gm_b", ",", "logger_cls", ",", "node_type_to_io_type_map", ")", "node_io_types_known_a_and_b", "=", "(", "node_input_type_a", "!=", "NodeInputOrOutputType", ".", "UNKNOWN", "and", "node_output_type_a", "!=", "NodeInputOrOutputType", ".", "UNKNOWN", "and", "node_input_type_b", "!=", "NodeInputOrOutputType", ".", "UNKNOWN", "and", "node_output_type_b", "!=", "NodeInputOrOutputType", ".", "UNKNOWN", ")", "if", "not", "node_io_types_known_a_and_b", ":", "print", "(", "f'skipping shadow loggers for node_b: {get_target_type_str(node_b, gm_b)}'", "+", "f', start_node_a: {get_target_type_str(subgraph_a.start_node, gm_a)}'", "+", "', unknown dtype cast'", ")", "env_c", "[", "node_b", ".", "name", "]", "=", "graph_c", ".", "node_copy", "(", "node_b", ",", "load_arg", ")", "continue", "# If we are shadowing from fp32 to int8, we need to insert", "# quantize_per_tensor call with qparams from the previous node.", "# Only do this if we are able to infer these qparams from the graph.", "if", "(", "node_input_type_a", "==", "NodeInputOrOutputType", ".", "INT8", "and", "node_input_type_b", "==", "NodeInputOrOutputType", ".", "FP32", ")", ":", "node_a_input_qparams", "=", "get_node_input_qparams", "(", "subgraph_a", ".", "start_node", ",", "gm_a", ",", "node_type_to_io_type_map", ")", "if", "not", "node_a_input_qparams", ":", "print", "(", "f'skipping shadow loggers for node_b: {get_target_type_str(node_b, gm_b)}'", "+", "f', start_node_a: {get_target_type_str(subgraph_a.start_node, gm_a)}'", "+", "', unknown input qparams'", ")", "env_c", "[", "node_b", ".", "name", "]", "=", "graph_c", ".", "node_copy", "(", "node_b", ",", "load_arg", ")", "continue", "fqn_base_a", "=", "_maybe_get_fqn", "(", "subgraph_a", ".", "base_op_node", ",", "gm_a", ")", "fqn_base_b", "=", "_maybe_get_fqn", "(", "subgraph_b", ".", "base_op_node", ",", "gm_b", ")", "if", "node_b_is_start_node", ":", "# if necessary, log the input of node_c", "if", "should_log_inputs", ":", "if", "isinstance", "(", "node_b", ".", "args", "[", "0", "]", ",", "Node", ")", ":", "prev_node_c", "=", "env_c", "[", "node_b", ".", "args", "[", "0", "]", ".", "name", "]", "env_c", "[", "prev_node_c", ".", "name", "]", "=", "_insert_logger_after_node", "(", "prev_node_c", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_b_inp_'", ",", "node_b", ".", "name", ",", "name_b", ",", "ref_name", ",", "ref_node_type_b", ",", "NSSingleResultValuesType", ".", "NODE_INPUT", ".", "value", ",", "index_within_arg", "=", "0", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_b", ")", "elif", "isinstance", "(", "node_b", ".", "args", "[", "0", "]", ",", "list", ")", ":", "# first, save the prev_node instances, because they", "# will be overwritten in the env after the first logger", "# is added", "prev_node_c_list", "=", "[", "env_c", "[", "arg", ".", "name", "]", "for", "arg", "in", "node_b", ".", "args", "[", "0", "]", "]", "for", "arg_idx", ",", "arg", "in", "enumerate", "(", "node_b", ".", "args", "[", "0", "]", ")", ":", "prev_node_c", "=", "prev_node_c_list", "[", "arg_idx", "]", "env_c", "[", "prev_node_c", ".", "name", "]", "=", "_insert_logger_after_node", "(", "prev_node_c", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_b_inp_'", ",", "node_b", ".", "name", ",", "name_b", ",", "ref_name", ",", "ref_node_type_b", ",", "NSSingleResultValuesType", ".", "NODE_INPUT", ".", "value", ",", "index_within_arg", "=", "arg_idx", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_b", ")", "else", ":", "# logging of inputs which are not lists is not supported yet", "raise", "AssertionError", "(", "f\"type {type(node_b.args[0])} is not handled yet\"", ")", "# subgraph so far:", "#", "# (prev_node_c)+ -> (logger_c_input)?", "# Note: this if statement is always True, spelling it out to clarify code", "# intent.", "if", "node_b_is_start_node", "or", "node_b_is_end_node", ":", "# ensure env_c is populated with base node", "env_c", "[", "node_b", ".", "name", "]", "=", "graph_c", ".", "node_copy", "(", "node_b", ",", "load_arg", ")", "node_c", "=", "env_c", "[", "node_b", ".", "name", "]", "# after this point,", "#", "# node_a is the original node from graph_a, with parent module gm_a", "# node_b is the original node from graph_b, with parent module gm_b", "# node_c is the copy of node_b in graph_c", "#", "# subgraph so far:", "#", "# (prev_node_c)+ -> (logger_c_input)? -> node_start_c", "if", "node_b_is_start_node", ":", "# cast dtype from the dtype of node_c's input to the dtype of", "# node_a's input (dequant, etc)", "prev_node_c", "=", "node_c", ".", "args", "[", "0", "]", "if", "should_log_inputs", ":", "# skip the input logger when inserting a dtype cast", "if", "isinstance", "(", "prev_node_c", ",", "Node", ")", ":", "prev_node_c", "=", "prev_node_c", ".", "args", "[", "0", "]", "elif", "isinstance", "(", "prev_node_c", ",", "list", ")", ":", "prev_node_c", "=", "[", "arg", ".", "args", "[", "0", "]", "for", "arg", "in", "prev_node_c", "]", "dtype_cast_node", "=", "_insert_dtype_cast_after_node", "(", "subgraph_a", ".", "start_node", ",", "node_c", ",", "prev_node_c", ",", "gm_a", ",", "gm_b", ",", "graph_c", ",", "node_b", ".", "name", "+", "'_dtype_cast_'", ",", "logger_cls", ",", "node_type_to_io_type_map", ")", "# note: not inserting to env_c because all nodes which use the dtype", "# casts are copied from graph_a", "#", "# subgraph so far:", "#", "# (dtype_cast_node)+", "# /", "# (prev_node_c)+ -> (logger_c_input)? -> node_start_c", "# if input logging is enabled, log the input to the subgraph", "if", "should_log_inputs", ":", "# TODO: explain this", "ref_node_name", "=", "''", "if", "isinstance", "(", "dtype_cast_node", ",", "Node", ")", ":", "dtype_cast_node", "=", "_insert_logger_after_node", "(", "dtype_cast_node", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_a_inp_'", ",", "ref_node_name", ",", "name_a", ",", "ref_name", ",", "ref_node_type_a", ",", "NSSingleResultValuesType", ".", "NODE_INPUT", ".", "value", ",", "index_within_arg", "=", "0", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_a", ")", "input_logger", ":", "Union", "[", "Node", ",", "List", "[", "Node", "]", "]", "=", "dtype_cast_node", "else", ":", "assert", "isinstance", "(", "dtype_cast_node", ",", "list", ")", "new_loggers", "=", "[", "]", "for", "dtype_cast_idx", ",", "dtype_cast_node_inner", "in", "enumerate", "(", "dtype_cast_node", ")", ":", "dtype_cast_logger", "=", "_insert_logger_after_node", "(", "dtype_cast_node_inner", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_a_inp_'", ",", "ref_node_name", ",", "name_a", ",", "ref_name", ",", "ref_node_type_a", ",", "NSSingleResultValuesType", ".", "NODE_INPUT", ".", "value", ",", "index_within_arg", "=", "dtype_cast_idx", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_a", ")", "new_loggers", ".", "append", "(", "dtype_cast_logger", ")", "dtype_cast_node", "=", "new_loggers", "input_logger", "=", "dtype_cast_node", "# subgraph so far:", "#", "# (dtype_cast_node)+ -> (logger_a_input)?", "# /", "# prev_node_c -> (logger_c_input)? -> node_start_c", "# hook up the new mod_a copy to be in the graph, receiving the", "# same inputs as mod_b does, with dtype cast to match a", "# Some ops, such as LSTMs, have two non-param inputs. If we have", "# such an op, pass the second param as well. Note: dtype casting", "# for the second param is not implemented yet, it can be added", "# later if there is a use case.", "node_c_second_non_param_arg", "=", "None", "num_non_param_args_node_a", "=", "get_number_of_non_param_args", "(", "subgraph_a", ".", "start_node", ",", "gm_a", ")", "if", "num_non_param_args_node_a", "==", "2", ":", "node_c_second_non_param_arg", "=", "node_c", ".", "args", "[", "1", "]", "node_a_shadows_c", "=", "_insert_copy_of_subgraph_a_after_input_node_c", "(", "dtype_cast_node", ",", "node_c_second_non_param_arg", ",", "subgraph_a", ",", "gm_a", ",", "gm_b", ",", "node_c", ".", "name", "+", "'_shadow_copy_'", ")", "env_c", "[", "node_a_shadows_c", ".", "name", "]", "=", "node_a_shadows_c", "# subgraph so far:", "#", "# dtype_cast_node -> (logger_a_input)? -> subgraph_a_copy(args/kwargs not shown)", "# /", "# (prev_node_c)+ -> (logger_c_input)? -> node_start_c", "if", "should_log_inputs", ":", "# When we created the input logger, we left the ref_node_name", "# as an empty string, because the subgraph copy did not exist", "# yet. Now that the subgraph copy exists, we modify this name", "# to its true value.", "# Note: the alternative to this is to create the input logger", "# after creating the subgraph, which is slightly more", "# complicated. This is the lesser of two evils.", "# input_logger = env_c[dtype_cast_node.name]", "# Find the first node in the subgraph", "cur_node", "=", "node_a_shadows_c", "while", "cur_node", ".", "args", "[", "0", "]", "!=", "input_logger", ":", "cur_node", "=", "cur_node", ".", "args", "[", "0", "]", "# type: ignore[assignment]", "if", "isinstance", "(", "input_logger", ",", "Node", ")", ":", "input_logger_mod", "=", "getattr", "(", "gm_b", ",", "input_logger", ".", "name", ")", "input_logger_mod", ".", "ref_node_name", "=", "cur_node", ".", "name", "else", ":", "assert", "isinstance", "(", "input_logger", ",", "list", ")", "for", "input_logger_inner", "in", "input_logger", ":", "input_logger_mod", "=", "getattr", "(", "gm_b", ",", "input_logger_inner", ".", "name", ")", "input_logger_mod", ".", "ref_node_name", "=", "cur_node", ".", "name", "# hook up a logger to the mod_a copy", "env_c", "[", "node_a_shadows_c", ".", "name", "]", "=", "_insert_logger_after_node", "(", "env_c", "[", "node_a_shadows_c", ".", "name", "]", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_a_'", ",", "node_a_shadows_c", ".", "name", ",", "name_a", ",", "ref_name", ",", "ref_node_type_a", ",", "NSSingleResultValuesType", ".", "NODE_OUTPUT", ".", "value", ",", "index_within_arg", "=", "0", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_a", ")", "# subgraph so far:", "#", "# dtype_cast_node -> (logger_a_input)? -> subgraph_a_copy -> logger_a", "# /", "# (prev_node_c)+ -> (logger_c_input)? -> node_start_c", "if", "node_b_is_end_node", ":", "# hook up a logger to the mod_b copy", "env_c", "[", "node_b", ".", "name", "]", "=", "_insert_logger_after_node", "(", "env_c", "[", "node_b", ".", "name", "]", ",", "gm_b", ",", "logger_cls", ",", "'_ns_logger_b_'", ",", "node_b", ".", "name", ",", "name_b", ",", "ref_name", ",", "ref_node_type_b", ",", "NSSingleResultValuesType", ".", "NODE_OUTPUT", ".", "value", ",", "index_within_arg", "=", "0", ",", "index_of_arg", "=", "0", ",", "fqn", "=", "fqn_base_b", ")", "# subgraph so far:", "#", "# dtype_cast_node -> (logger_a_input)? -> subgraph_a_copy -> logger_a", "# /", "# (prev_node_c+) -> (logger_c_input)? -> node_start_c -> ... -> node_end_c -> logger_c", "#", "# Note: node_start_c may be the same node as node_end_c, or they", "# may have nodes inbetween.", "else", ":", "env_c", "[", "node_b", ".", "name", "]", "=", "graph_c", ".", "node_copy", "(", "node_b", ",", "load_arg", ")", "gm_c", "=", "GraphModule", "(", "gm_b", ",", "graph_c", ")", "return", "gm_c" ]

[ "return", "a", "uint64", "ndarray", "of", "my", "hashed", "values" ]

[ "def", "_hashed_values", "(", "self", ")", ":", "return", "hash_tuples", "(", "self", ")" ]

[ "File", "has", "no", "source", "file", "extension", "." ]

[ "def", "NoExtension", "(", "self", ")", ":", "return", "'/'", ".", "join", "(", "self", ".", "Split", "(", ")", "[", "0", ":", "2", "]", ")" ]

[ "Sets", "the", "initializer", "that", "will", "fill", "in", "the", "weight", "values", "before", "training", "starts", "." ]

[ "def", "initializer", "(", "self", ",", "new_initializer", ")", ":", "self", ".", "set_initializer", "(", "new_initializer", ".", "_internal", ")" ]

[ "Returns", "a", "tuple", "(", "<supported", ">", "<error", "message", ">", ")", "where", "<supported", ">", "is", "True", "if", "setting", "maxIndividualTestTime", "is", "supported", "on", "the", "current", "host", "returns", "False", "otherwise", ".", "<error", "message", ">", "is", "an", "empty", "string", "if", "<supported", ">", "is", "True", "otherwise", "is", "contains", "a", "string", "describing", "why", "setting", "maxIndividualTestTime", "is", "not", "supported", "." ]

[ "def", "maxIndividualTestTimeIsSupported", "(", "self", ")", ":", "return", "lit", ".", "util", ".", "killProcessAndChildrenIsSupported", "(", ")" ]

[ "Add", "the", "subgraph", "defined", "by", "fn", "()", "to", "the", "graph", "." ]

[ "def", "BuildCondBranch", "(", "self", ",", "fn", ")", ":", "r", "=", "fn", "(", ")", "original_r", "=", "r", "result", "=", "[", "]", "if", "r", "is", "not", "None", ":", "if", "not", "isinstance", "(", "r", ",", "list", ")", "and", "not", "isinstance", "(", "r", ",", "_basetuple", ")", ":", "r", "=", "[", "r", "]", "original_r", "=", "[", "original_r", "]", "r", "=", "_convert_tensorarrays_to_flows", "(", "r", ")", "for", "v", "in", "r", ":", "real_v", "=", "v", "if", "isinstance", "(", "v", ",", "ops", ".", "Operation", ")", ":", "# Use pivot as the proxy for this op.", "real_v", "=", "with_dependencies", "(", "[", "v", "]", ",", "self", ".", "_pivot", ")", "elif", "v", ".", "name", "not", "in", "self", ".", "_values", ":", "# Handle the special case of lambda: x", "self", ".", "_values", ".", "add", "(", "v", ".", "name", ")", "if", "self", ".", "_outer_context", ":", "real_v", "=", "self", ".", "_outer_context", ".", "AddValue", "(", "v", ")", "self", ".", "_values", ".", "add", "(", "real_v", ".", "name", ")", "real_v", "=", "_SwitchRefOrTensor", "(", "real_v", ",", "self", ".", "_pred", ")", "[", "self", ".", "_branch", "]", "self", ".", "_external_values", "[", "v", ".", "name", "]", "=", "real_v", "else", ":", "external_v", "=", "self", ".", "_external_values", ".", "get", "(", "v", ".", "name", ")", "if", "external_v", "is", "not", "None", ":", "real_v", "=", "external_v", "result", ".", "append", "(", "real_v", ")", "return", "original_r", ",", "result" ]

[ "Return", "an", "OS", "version", "suitable", "for", "package", "repo", "directory", "naming", "-", "e", ".", "g", ".", "5", "6", "or", "7", "for", "redhat", "/", "centos", "precise", "wheezy", "etc", ".", "for", "Ubuntu", "/", "Debian", "11", "for", "suse", "2013", ".", "03", "for", "amazon" ]

[ "def", "repo_os_version", "(", "self", ",", "build_os", ")", ":", "if", "self", ".", "n", "==", "'suse'", ":", "return", "re", ".", "sub", "(", "r'^suse(\\d+)$'", ",", "r'\\1'", ",", "build_os", ")", "if", "self", ".", "n", "==", "'redhat'", ":", "return", "re", ".", "sub", "(", "r'^rhel(\\d).*$'", ",", "r'\\1'", ",", "build_os", ")", "if", "self", ".", "n", "==", "'amazon'", ":", "return", "\"2013.03\"", "elif", "self", ".", "n", "==", "'ubuntu'", ":", "if", "build_os", "==", "'ubuntu1204'", ":", "return", "\"precise\"", "elif", "build_os", "==", "'ubuntu1404'", ":", "return", "\"trusty\"", "elif", "build_os", "==", "'ubuntu1604'", ":", "return", "\"xenial\"", "else", ":", "raise", "Exception", "(", "\"unsupported build_os: %s\"", "%", "build_os", ")", "elif", "self", ".", "n", "==", "'debian'", ":", "if", "build_os", "==", "'debian71'", ":", "return", "'wheezy'", "elif", "build_os", "==", "'debian81'", ":", "return", "'jessie'", "else", ":", "raise", "Exception", "(", "\"unsupported build_os: %s\"", "%", "build_os", ")", "else", ":", "raise", "Exception", "(", "\"unsupported distro: %s\"", "%", "self", ".", "n", ")" ]

[ "The", "qualified", "name", "of", "this", "type", "." ]

[ "def", "drake_type", "(", "self", ")", ":", "return", "'%s.%s'", "%", "(", "self", ".", "__module__", ",", "self", ".", "__name__", ")" ]

[ "Probability", "of", "drawing", "a", "1", "." ]

[ "def", "probs", "(", "self", ")", ":", "return", "self", ".", "_probs" ]

[ "Get", "value", "from", "config", "using", "trait", ".", "An", "exception", "will", "be", "thrown", "if", "the", "config", "trait", "has", "not", "been", "registered", "with", "the", "process", "." ]

[ "def", "config_value_using_trait", "(", "self", ",", "name", ")", ":", "ct", "=", "self", ".", "_config_trait_set", ".", "get", "(", "name", ",", "None", ")", "if", "ct", "is", "None", ":", "raise", "ValueError", "(", "'config trait name \\\"%s\\\" not registered'", "%", "name", ")", "return", "self", ".", "config_value", "(", "ct", ".", "name", ")" ]

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

[ "def", "removeNthFromEnd", "(", "self", ",", "head", ",", "n", ")", ":", "h", "=", "ListNode", "(", "-", "1", ")", "h", ".", "next", "=", "head", "p", ",", "q", "=", "h", ",", "h", "for", "_", "in", "range", "(", "n", "+", "1", ")", ":", "assert", "(", "q", ")", "q", "=", "q", ".", "next", "while", "q", "!=", "None", ":", "p", "=", "p", ".", "next", "q", "=", "q", ".", "next", "p", ".", "next", "=", "p", ".", "next", ".", "next", "return", "h", ".", "next" ]

[ "Convert", "costs", "to", "weights", "using", "different", "weighting", "methods", ".", "\\", "param", "[", "in", "]", "costs", "A", "vector", "of", "costs", ".", "\\", "param", "[", "in", "]", "weighting_method", "The", "weighting", "method", "(", "PI", "-", "BB", "CMA", "-", "ES", "CEM", ")", "\\", "param", "[", "in", "]", "eliteness", "The", "eliteness", "parameter", "(", "h", "in", "PI", "-", "BB", "mu", "in", "CMA", "-", "ES", ")", "\\", "return", "A", "vector", "of", "weights", "(", "they", "always", "sum", "to", "1", ")", "." ]

[ "def", "costsToWeights", "(", "costs", ",", "weighting_method", ",", "eliteness", ")", ":", "# Costs can be a 2D array or a list of lists. In this case, the first", "# column is the sum of the other columns (which contain the different cost", "# components). In this case, we should use only the first column.", "costs", "=", "np", ".", "asarray", "(", "[", "np", ".", "atleast_1d", "(", "x", ")", "[", "0", "]", "for", "x", "in", "costs", "]", ")", "#np.set_printoptions(precision=4, suppress=True)", "if", "weighting_method", "==", "'PI-BB'", ":", "# PI^2 style weighting: continuous, cost exponention", "h", "=", "eliteness", "# In PI^2, eliteness parameter is known as \"h\"", "costs_range", "=", "max", "(", "costs", ")", "-", "min", "(", "costs", ")", "if", "costs_range", "==", "0", ":", "weights", "=", "np", ".", "full", "(", "costs", ".", "shape", ",", "1.0", ")", "else", ":", "costs_norm", "=", "np", ".", "asarray", "(", "[", "-", "h", "*", "(", "x", "-", "min", "(", "costs", ")", ")", "/", "costs_range", "for", "x", "in", "costs", "]", ")", "weights", "=", "np", ".", "exp", "(", "costs_norm", ")", "elif", "weighting_method", "==", "'CEM'", "or", "weighting_method", "==", "'CMA-ES'", ":", "# CEM/CMA-ES style weights: rank-based, uses defaults", "mu", "=", "eliteness", "# In CMA-ES, eliteness parameter is known as \"mu\"", "indices", "=", "np", ".", "argsort", "(", "costs", ")", "weights", "=", "np", ".", "full", "(", "costs", ".", "size", ",", "0.0", ")", "if", "weighting_method", "==", "'CEM'", ":", "# CEM", "weights", "[", "indices", "[", "0", ":", "mu", "]", "]", "=", "1.0", "/", "mu", "else", ":", "# CMA-ES", "for", "ii", "in", "range", "(", "mu", ")", ":", "weights", "[", "indices", "[", "ii", "]", "]", "=", "np", ".", "log", "(", "mu", "+", "0.5", ")", "-", "np", ".", "log", "(", "ii", "+", "1", ")", "else", ":", "print", "(", "\"WARNING: Unknown weighting method '\"", ",", "weighting_method", ",", "\"'. Calling with PI-BB weighting.\"", ")", "return", "costsToWeights", "(", "costs", ",", "'PI-BB'", ",", "eliteness", ")", "#// Relative standard deviation of total costs", "#double mean = weights.mean();", "#double std = sqrt((weights.array()-mean).pow(2).mean());", "#double rel_std = std/mean;", "#if (rel_std<1e-10)", "#{", "# // Special case: all costs are the same", "# // Set same weights for all.", "# weights.fill(1);", "#}", "# Normalize weights", "weights", "=", "weights", "/", "sum", "(", "weights", ")", "return", "weights" ]

[ "Convert", "a", "block", "(", "sub", "-", "graph", ")", "to", "MIL", ".", "Conversion", "happens", "within", "a", "new", "context", "frame", "." ]

[ "def", "convert_block", "(", "context", ",", "block", ",", "inputs", ")", ":", "assert", "len", "(", "block", ".", "inputs", ")", "==", "len", "(", "inputs", ")", "# Start a new context frame.", "context", ".", "push", "(", "(", "block", ".", "inputs", ",", "inputs", ")", ")", "# Add the block ops.", "convert_nodes", "(", "context", ",", "block", ")", "# Collect the block outputs.", "outputs", "=", "[", "context", "[", "outp", "]", "for", "outp", "in", "block", ".", "outputs", "]", "# Return to the previous context frame.", "context", ".", "pop", "(", ")", "return", "outputs" ]

[ "Retrieve", "the", "ref", "-", "qualifier", "of", "the", "type", "." ]

[ "def", "get_ref_qualifier", "(", "self", ")", ":", "return", "RefQualifierKind", ".", "from_id", "(", "conf", ".", "lib", ".", "clang_Type_getCXXRefQualifier", "(", "self", ")", ")" ]

[ "r", "Computes", "dot", "-", "product", "of", "two", "vectors", "inp1", "and", "inp2", ".", "inputs", "must", "be", "1", "-", "dimensional", "or", "scalar", ".", "A", "scalar", "input", "is", "automatically", "broadcasted", ".", "Refer", "to", ":", "func", ":", "~", ".", "matmul", "for", "more", "general", "usage", "." ]

[ "def", "dot", "(", "inp1", ":", "Tensor", ",", "inp2", ":", "Tensor", ")", "->", "Tensor", ":", "op", "=", "builtin", ".", "Dot", "(", ")", "assert", "(", "inp1", ".", "ndim", "<=", "1", "and", "inp2", ".", "ndim", "<=", "1", ")", ",", "\"Input tensors for dot must be 1-dimensional or scalar\"", "(", "result", ",", ")", "=", "apply", "(", "op", ",", "inp1", ",", "inp2", ")", "return", "result" ]

[ "Get", "the", "file", "offset", "represented", "by", "this", "source", "location", "." ]

[ "def", "offset", "(", "self", ")", ":", "return", "self", ".", "_get_instantiation", "(", ")", "[", "3", "]" ]

[ "Copy", "data", "files", "into", "build", "directory" ]

[ "def", "build_package_data", "(", "self", ")", ":", "lastdir", "=", "None", "for", "package", ",", "src_dir", ",", "build_dir", ",", "filenames", "in", "self", ".", "data_files", ":", "for", "filename", "in", "filenames", ":", "target", "=", "os", ".", "path", ".", "join", "(", "build_dir", ",", "filename", ")", "self", ".", "mkpath", "(", "os", ".", "path", ".", "dirname", "(", "target", ")", ")", "self", ".", "copy_file", "(", "os", ".", "path", ".", "join", "(", "src_dir", ",", "filename", ")", ",", "target", ",", "preserve_mode", "=", "False", ")" ]

[ "Returns", "True", "iff", "the", "given", "filename", "is", "a", "genuine", "JPEG", "-", "XL", "file", "." ]

[ "def", "is_jpegxl_recompressed_jpeg_file", "(", "filename", ")", ":", "try", ":", "with", "open", "(", "filename", ",", "'rb'", ")", "as", "h", ":", "header", "=", "h", ".", "read", "(", "len", "(", "JPEGXL_RECOMPRESSED_JPEG_HEADER", ")", ")", "# Cf. https://arxiv.org/pdf/1908.03565.pdf, section 9.1,", "# on recompressed-JPEG header.", "return", "header", "==", "JPEGXL_RECOMPRESSED_JPEG_HEADER", "except", ":", "# pylint:disable=bare-except", "# If anything failed, this means that we cannot establish that the file", "# has the expected header, so we return False.", "return", "False" ]

[ "Return", "the", "host", "on", "which", "a", "client", "can", "connect", "to", "the", "given", "listener", "." ]

[ "def", "client_host", "(", "server_host", ")", ":", "if", "server_host", "==", "'0.0.0.0'", ":", "# 0.0.0.0 is INADDR_ANY, which should answer on localhost.", "return", "'127.0.0.1'", "if", "server_host", "in", "(", "'::'", ",", "'::0'", ",", "'::0.0.0.0'", ")", ":", "# :: is IN6ADDR_ANY, which should answer on localhost.", "# ::0 and ::0.0.0.0 are non-canonical but common ways to write IN6ADDR_ANY.", "return", "'::1'", "return", "server_host" ]

[ "Unit", "impulse", "signal", "(", "discrete", "delta", "function", ")", "or", "unit", "basis", "vector", "." ]

[ "def", "unit_impulse", "(", "shape", ",", "idx", "=", "None", ",", "dtype", "=", "float", ")", ":", "out", "=", "zeros", "(", "shape", ",", "dtype", ")", "shape", "=", "np", ".", "atleast_1d", "(", "shape", ")", "if", "idx", "is", "None", ":", "idx", "=", "(", "0", ",", ")", "*", "len", "(", "shape", ")", "elif", "idx", "==", "'mid'", ":", "idx", "=", "tuple", "(", "shape", "//", "2", ")", "elif", "not", "hasattr", "(", "idx", ",", "\"__iter__\"", ")", ":", "idx", "=", "(", "idx", ",", ")", "*", "len", "(", "shape", ")", "out", "[", "idx", "]", "=", "1", "return", "out" ]

[ "Whether", "to", "use", "L2", "weight", "decay", "for", "param_name", "." ]

[ "def", "_do_use_weight_decay", "(", "self", ",", "param_name", ")", ":", "if", "not", "self", ".", "weight_decay_rate", ":", "return", "False", "if", "self", ".", "exclude_from_weight_decay", ":", "for", "r", "in", "self", ".", "exclude_from_weight_decay", ":", "if", "re", ".", "search", "(", "r", ",", "param_name", ")", "is", "not", "None", ":", "return", "False", "return", "True" ]

[ "1", ".", "unified", "activation", "bits", "2", ".", "mixed", "bits", "for", "lstm" ]

[ "def", "_get_default_quant_config", "(", "self", ",", "quant_info_mgr", ",", "lstm", "=", "False", ")", ":", "# import ipdb", "# ipdb.set_trace()", "config", "=", "{", "'param'", ":", "{", "}", ",", "'output'", ":", "{", "}", ",", "'input'", ":", "{", "}", "}", "for", "node", "in", "quant_info_mgr", ".", "Nndctgraph", ".", "nodes", ":", "# print('---- Handling node %s type: %s' % (node.name, node.op.type))", "if", "quant_info_mgr", ".", "is_node_quantizable", "(", "node", ",", "lstm", ")", ":", "# parameters", "for", "k", "in", "quant_info_mgr", ".", "quant_node_params", "(", "node", ")", ".", "keys", "(", ")", ":", "p", "=", "quant_info_mgr", ".", "quant_node_params", "(", "node", ")", "[", "k", "]", "# for mix precision quantization", "bw", "=", "self", ".", "_bits_act", "if", "(", "node", ".", "has_bound_params", "(", ")", "and", "(", "hasattr", "(", "node", ".", "op", ".", "ParamName", ",", "'WEIGHTS'", ")", "and", "k", "==", "node", ".", "op", ".", "ParamName", ".", "WEIGHTS", "or", "hasattr", "(", "node", ".", "op", ".", "ParamName", ",", "'GAMMA'", ")", "and", "k", "==", "node", ".", "op", ".", "ParamName", ".", "GAMMA", ")", ")", ":", "bw", "=", "self", ".", "_bits_weight", "config", "[", "'param'", "]", "[", "p", ".", "name", "]", "=", "[", "bw", ",", "None", "]", "# print('---- Add fix of param %s' % p.name)", "# output blobs", "end", "=", "quant_info_mgr", ".", "quant_output", "(", "node", ".", "name", ")", ".", "name", "if", "end", "not", "in", "config", "[", "'output'", "]", ":", "config", "[", "'output'", "]", "[", "end", "]", "=", "[", "self", ".", "_bits_act", ",", "None", "]", "# print('---- Add fix of output blob %s' % end)", "# input blobs (for mix precision quantization)", "if", "self", ".", "_bits_weight", "!=", "self", ".", "_bits_act", ":", "if", "node", ".", "op", ".", "type", "in", "[", "NNDCT_OP", ".", "DENSE", ",", "NNDCT_OP", ".", "CONV2D", "]", ":", "config", "[", "'input'", "]", "[", "node", ".", "name", "]", "=", "[", "self", ".", "_bits_weight", ",", "None", "]", "# print('---- Add fix of input blob %s' % end)", "elif", "(", "lstm", "and", "(", "node", "in", "quant_info_mgr", ".", "Nndctgraph", ".", "inputs", ")", ")", ":", "# print('---- Handling input node %s' % (node.name))", "# this path is only for quantizing a whole graph without quant stub OP", "# for lstm, check the following node type", "if", "(", "node", ".", "in_quant_part", "or", "(", "any", "(", "(", "quant_info_mgr", ".", "is_node_quantizable", "(", "c", ",", "lstm", ")", "and", "c", ".", "op", ".", "type", "is", "not", "NNDCT_OP", ".", "QUANT_STUB", ")", "for", "c", "in", "quant_info_mgr", ".", "Nndctgraph", ".", "children", "(", "node", ".", "name", ")", ")", ")", ")", ":", "end", "=", "quant_info_mgr", ".", "quant_output", "(", "node", ".", "name", ")", ".", "name", "if", "end", "not", "in", "config", "[", "'output'", "]", ":", "config", "[", "'output'", "]", "[", "end", "]", "=", "[", "self", ".", "_bits_act", ",", "None", "]", "# print('---- Add fix of quant net input blob %s' % end)", "# check the input fix of all quantized ops ", "# import ipdb", "# ipdb.set_trace()", "if", "not", "lstm", ":", "for", "node", "in", "quant_info_mgr", ".", "Nndctgraph", ".", "nodes", ":", "if", "quant_info_mgr", ".", "is_node_quantizable", "(", "node", ",", "lstm", ")", ":", "#print('---- Check input of node %s type: %s' % (node.name, node.op.type))", "if", "node", ".", "op", ".", "type", "not", "in", "[", "NNDCT_OP", ".", "INPUT", ",", "NNDCT_OP", ".", "QUANT_STUB", ",", "NNDCT_OP", ".", "CONCAT", "]", ":", "for", "p_n", "in", "quant_info_mgr", ".", "Nndctgraph", ".", "parents", "(", "node", ")", ":", "# if not quant_info_mgr.op_unquantizable(p_n.op.type):", "end", "=", "quant_info_mgr", ".", "quant_output", "(", "p_n", ".", "name", ")", ".", "name", "end_node", "=", "quant_info_mgr", ".", "Nndctgraph", ".", "node", "(", "end", ")", "out_is_tensor", "=", "True", "for", "tensor", "in", "end_node", ".", "out_tensors", ":", "if", "tensor", ".", "shape", "==", "None", ":", "out_is_tensor", "=", "False", "if", "end", "not", "in", "config", "[", "'output'", "]", "and", "out_is_tensor", ":", "config", "[", "'output'", "]", "[", "end", "]", "=", "[", "self", ".", "_bits_act", ",", "None", "]", "#print('---- Add fix of output blob %s type: %s' % (end, end_node.op.type))", "elif", "node", ".", "op", ".", "type", "in", "[", "NNDCT_OP", ".", "INPUT", "]", ":", "cn_nodes", "=", "quant_info_mgr", ".", "Nndctgraph", ".", "children", "(", "node", ")", "if", "len", "(", "cn_nodes", ")", "==", "1", "and", "cn_nodes", "[", "0", "]", ".", "op", ".", "is_custom_op", ":", "end", "=", "quant_info_mgr", ".", "quant_output", "(", "node", ".", "name", ")", ".", "name", "if", "end", "in", "config", "[", "'output'", "]", ":", "del", "config", "[", "'output'", "]", "[", "end", "]", "node", ".", "in_quant_part", "=", "False", "return", "config" ]

[ "Method", "called", "to", "apply", "the", "reduction", "script", "element", "to", "a", "Mantid", "Reducer" ]

[ "def", "apply", "(", "self", ")", ":", "return", "NotImplemented" ]

[ "If", "the", "concrete", "completer", "wants", "to", "respond", "to", "workspace", "/", "configuration", "requests", "it", "should", "override", "this", "method", "." ]

[ "def", "WorkspaceConfigurationResponse", "(", "self", ",", "request", ")", ":", "return", "None" ]

[ "Convert", "a", "byte", "string", "to", "str", "using", "string_encoding", "and", "decode_errors", "." ]

[ "def", "_bytes_to_str", "(", "self", ",", "_bytes", ")", ":", "assert", "type", "(", "_bytes", ")", "==", "bytes", "return", "str", "(", "_bytes", ",", "self", ".", "string_encoding", ",", "self", ".", "decode_errors", ")" ]

[ "This", "converts", "from", "the", "external", "coding", "system", "(", "as", "passed", "to", "the", "constructor", ")", "to", "the", "internal", "one", "(", "unicode", ")", "." ]

[ "def", "_decode", "(", "self", ",", "s", ")", ":", "if", "self", ".", "decoder", "is", "not", "None", ":", "return", "self", ".", "decoder", ".", "decode", "(", "s", ")", "else", ":", "raise", "TypeError", "(", "\"This screen was constructed with encoding=None, \"", "\"so it does not handle bytes.\"", ")" ]

[ "Tableau", "10", "colors", "as", "RGB" ]

[ "def", "tableau10", "(", ")", ":", "colors", "=", "[", "(", "31", ",", "119", ",", "180", ")", ",", "(", "255", ",", "127", ",", "14", ")", ",", "(", "44", ",", "160", ",", "44", ")", ",", "(", "214", ",", "39", ",", "40", ")", ",", "(", "148", ",", "103", ",", "189", ")", ",", "(", "140", ",", "86", ",", "75", ")", ",", "(", "227", ",", "119", ",", "194", ")", ",", "(", "127", ",", "127", ",", "127", ")", ",", "(", "188", ",", "189", ",", "34", ")", ",", "(", "23", ",", "190", ",", "207", ")", "]", "return", "rgb2float", "(", "colors", ")" ]

[ "Returns", "a", "GraphSet", "of", "paths", "." ]

[ "def", "paths", "(", "terminal1", ",", "terminal2", ",", "is_hamilton", "=", "False", ",", "graphset", "=", "None", ")", ":", "dc", "=", "{", "}", "for", "v", "in", "GraphSet", ".", "_vertices", ":", "if", "v", "in", "(", "terminal1", ",", "terminal2", ")", ":", "dc", "[", "v", "]", "=", "1", "else", ":", "dc", "[", "v", "]", "=", "2", "if", "is_hamilton", "else", "range", "(", "0", ",", "3", ",", "2", ")", "return", "GraphSet", ".", "graphs", "(", "vertex_groups", "=", "[", "[", "terminal1", ",", "terminal2", "]", "]", ",", "degree_constraints", "=", "dc", ",", "no_loop", "=", "True", ",", "graphset", "=", "graphset", ")" ]

[ "return", "the", "size", "of", "the", "next", "object", "." ]

[ "def", "_get_size", "(", "self", ",", "tokenL", ")", ":", "if", "tokenL", "==", "0xF", ":", "m", "=", "self", ".", "_fp", ".", "read", "(", "1", ")", "[", "0", "]", "&", "0x3", "s", "=", "1", "<<", "m", "f", "=", "'>'", "+", "_BINARY_FORMAT", "[", "s", "]", "return", "struct", ".", "unpack", "(", "f", ",", "self", ".", "_fp", ".", "read", "(", "s", ")", ")", "[", "0", "]", "return", "tokenL" ]

[ "Send", "bytes", "to", "the", "input", "." ]

[ "def", "send_bytes", "(", "self", ",", "data", ":", "bytes", ")", "->", "None", ":", "self", ".", "send_text", "(", "data", ".", "decode", "(", "\"utf-8\"", ",", "\"ignore\"", ")", ")" ]

[ "Given", "a", "metric", "name", "return", "the", "corresponding", "metric", "function", "." ]

[ "def", "get_metric", "(", "metric_name", ")", ":", "return", "_EVAL_METRICS", "[", "metric_name", "]" ]

[ "Gets", "a", "phony", ".", "Phony", "is", "tensor", "without", "space", ".", "It", "is", "useful", "to", "make", "arbitrary", "dependency", "in", "a", "autograd", "graph", "because", "it", "doesn", "t", "require", "any", "gradient", "accumulation", "." ]

[ "def", "get_phony", "(", "device", ":", "torch", ".", "device", ",", "*", ",", "requires_grad", ":", "bool", ")", "->", "Tensor", ":", "key", "=", "(", "device", ",", "requires_grad", ")", "try", ":", "phony", "=", "_phonies", "[", "key", "]", "except", "KeyError", ":", "with", "use_stream", "(", "default_stream", "(", "device", ")", ")", ":", "phony", "=", "torch", ".", "empty", "(", "0", ",", "device", "=", "device", ",", "requires_grad", "=", "requires_grad", ")", "_phonies", "[", "key", "]", "=", "phony", "return", "phony" ]

[ "Control_RemoveMnemonics", "(", "String", "str", ")", "-", ">", "String" ]

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

[ "Produces", "a", "slice", "of", "each", "Tensor", "in", "tensor_list", "." ]

[ "def", "slice_input_producer", "(", "tensor_list", ",", "num_epochs", "=", "None", ",", "shuffle", "=", "True", ",", "seed", "=", "None", ",", "capacity", "=", "32", ",", "shared_name", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"input_producer\"", ",", "tensor_list", ")", ":", "tensor_list", "=", "ops", ".", "convert_n_to_tensor_or_indexed_slices", "(", "tensor_list", ")", "if", "not", "tensor_list", ":", "raise", "ValueError", "(", "\"Expected at least one tensor in slice_input_producer().\"", ")", "range_size", "=", "array_ops", ".", "shape", "(", "tensor_list", "[", "0", "]", ")", "[", "0", "]", "# TODO(josh11b): Add an assertion that the first dimension of", "# everything in TensorList matches. Maybe just check the inferred shapes?", "queue", "=", "range_input_producer", "(", "range_size", ",", "num_epochs", "=", "num_epochs", ",", "shuffle", "=", "shuffle", ",", "seed", "=", "seed", ",", "capacity", "=", "capacity", ",", "shared_name", "=", "shared_name", ")", "index", "=", "queue", ".", "dequeue", "(", ")", "output", "=", "[", "array_ops", ".", "gather", "(", "t", ",", "index", ")", "for", "t", "in", "tensor_list", "]", "return", "output" ]

[ "GetObject", "(", "self", "DataFormat", "format", "wxDataObjectBase", "::", "Direction", "dir", "=", "Get", ")", "-", ">", "DataObjectSimple" ]

[ "def", "GetObject", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DataObjectComposite_GetObject", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "See", "Dataset", ".", "zip", "()", "for", "details", "." ]

[ "def", "__init__", "(", "self", ",", "datasets", ")", ":", "super", "(", "ZipDataset", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "_datasets", "=", "datasets" ]

[ "Retrieve", "the", "offset", "of", "a", "field", "in", "the", "record", "." ]

[ "def", "get_offset", "(", "self", ",", "fieldname", ")", ":", "return", "conf", ".", "lib", ".", "clang_Type_getOffsetOf", "(", "self", ",", "fieldname", ")" ]

[ "derivatice", "of", "complex", "muliplication", "wrt", "left", "multiplier", "a" ]

[ "def", "Da_a_mul_b", "(", "a", ",", "b", ")", ":", "return", "sympy", ".", "Matrix", "(", "[", "[", "b", ".", "real", ",", "-", "b", ".", "imag", "]", ",", "[", "b", ".", "imag", ",", "b", ".", "real", "]", "]", ")" ]

[ "Tries", "to", "determine", "the", "name", "of", "the", "Linux", "OS", "distribution", "name", "." ]

[ "def", "linux_distribution", "(", "distname", "=", "''", ",", "version", "=", "''", ",", "id", "=", "''", ",", "supported_dists", "=", "_supported_dists", ",", "full_distribution_name", "=", "1", ")", ":", "try", ":", "etc", "=", "os", ".", "listdir", "(", "'/etc'", ")", "except", "os", ".", "error", ":", "# Probably not a Unix system", "return", "distname", ",", "version", ",", "id", "etc", ".", "sort", "(", ")", "for", "file", "in", "etc", ":", "m", "=", "_release_filename", ".", "match", "(", "file", ")", "if", "m", "is", "not", "None", ":", "_distname", ",", "dummy", "=", "m", ".", "groups", "(", ")", "if", "_distname", "in", "supported_dists", ":", "distname", "=", "_distname", "break", "else", ":", "return", "_dist_try_harder", "(", "distname", ",", "version", ",", "id", ")", "# Read the first line", "f", "=", "open", "(", "'/etc/'", "+", "file", ",", "'r'", ")", "firstline", "=", "f", ".", "readline", "(", ")", "f", ".", "close", "(", ")", "_distname", ",", "_version", ",", "_id", "=", "_parse_release_file", "(", "firstline", ")", "if", "_distname", "and", "full_distribution_name", ":", "distname", "=", "_distname", "if", "_version", ":", "version", "=", "_version", "if", "_id", ":", "id", "=", "_id", "return", "distname", ",", "version", ",", "id" ]

[ "product_source_name", "()", "-", ">", "str" ]

[ "def", "product_source_name", "(", "cls", ")", ":", "return", "\"swift-syntax\"" ]

[ "Sets", "the", "i", "th", "entry", "of", "the", "C", "vector", "to", "a", "fixed", "value" ]

[ "def", "fixC", "(", "self", ",", "i", ",", "value", ")", ":", "if", "self", ".", "coeffPattern", "[", "2", "]", "==", "None", ":", "m", ",", "n", "=", "self", ".", "m", ",", "self", ".", "n", "self", ".", "coeffPattern", "[", "2", "]", "=", "[", "None", "]", "*", "m", "self", ".", "coeffPattern", "[", "2", "]", "[", "i", "]", "=", "value", "self", ".", "_updateEstimatorSize", "(", "i", ")" ]

[ "No", "need", "to", "nest", "ShellQuoted", "." ]

[ "def", "__new__", "(", "cls", ",", "s", ")", ":", "return", "super", "(", "ShellQuoted", ",", "cls", ")", ".", "__new__", "(", "cls", ",", "s", ".", "do_not_use_raw_str", "if", "isinstance", "(", "s", ",", "ShellQuoted", ")", "else", "s", ")" ]

[ "This", "moves", "the", "cursor", "to", "the", "beginning", "(", "col", "1", ")", "of", "the", "current", "row", "." ]

[ "def", "cr", "(", "self", ")", ":", "self", ".", "cursor_home", "(", "self", ".", "cur_r", ",", "1", ")" ]

[ "Args", ":", "I", ":", "3x3", "intrinsic", "camera", "matrix", "from", "real", "camera", "(", "without", "any", "OpenGL", "stuff", ")", "W", ":", "Width", "of", "the", "camera", "image", "H", ":", "Height", "of", "the", "camera", "image", "near", ":", "Near", "plane", "far", ":", "Far", "plane", "originIsInTopLeft", ":", "If", "True", "then", "the", "image", "origin", "is", "in", "top", "left", "if", "False", "the", "image", "origin", "is", "in", "image", "center", "Source", ":", "http", ":", "//", "ksimek", ".", "github", ".", "io", "/", "2013", "/", "06", "/", "03", "/", "calibrated_cameras_in_opengl", "/" ]

[ "def", "setIntrinsic", "(", "self", ",", "I", ",", "W", ",", "H", ",", "near", ",", "far", ",", "scale", "=", "1.0", ",", "originIsInTopLeft", "=", "True", ")", ":", "Camera", ".", "__check_matrix__", "(", "I", ")", "A", "=", "near", "+", "far", "B", "=", "near", "*", "far", "persp", "=", "np", ".", "array", "(", "[", "[", "I", "[", "0", ",", "0", "]", "*", "scale", ",", "I", "[", "0", ",", "1", "]", "*", "scale", ",", "-", "I", "[", "0", ",", "2", "]", "*", "scale", ",", "0", "]", ",", "[", "0", ",", "I", "[", "1", ",", "1", "]", "*", "scale", ",", "-", "I", "[", "1", ",", "2", "]", "*", "scale", ",", "0", "]", ",", "[", "0", ",", "0", ",", "A", ",", "B", "]", ",", "[", "0", ",", "0", ",", "-", "1", ",", "0", "]", "]", ",", "dtype", "=", "np", ".", "float64", ")", "ortho", "=", "Camera", ".", "__glOrtho__", "(", "0", ",", "W", ",", "H", ",", "0", ",", "near", ",", "far", ")", "if", "originIsInTopLeft", "else", "Camera", ".", "__glOrtho__", "(", "-", "W", "/", "2.", ",", "W", "/", "2.", ",", "-", "H", "/", "2.", ",", "H", "/", "2.", ",", "near", ",", "far", ")", "self", ".", "__T_proj_view", "[", ":", "]", "=", "np", ".", "dot", "(", "ortho", ",", "persp", ")", ".", "astype", "(", "np", ".", "float32", ")", "self", ".", "__T_view_proj", "[", ":", "]", "=", "np", ".", "linalg", ".", "inv", "(", "self", ".", "__T_proj_view", ")", "self", ".", "__T_proj_world", "[", ":", "]", "=", "np", ".", "dot", "(", "self", ".", "__T_proj_view", ",", "self", ".", "__T_view_world", ")", "self", ".", "dirty", "=", "True" ]

[ "Create", "a", "file", "-", "like", "object", "." ]

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

[ "Remove", "ansi", "escape", "codes", "from", "text", ".", "Parameters", "----------", "source", ":", "str", "Source", "to", "remove", "the", "ansi", "from" ]

[ "def", "strip_ansi", "(", "source", ")", ":", "return", "re", ".", "sub", "(", "r'\\033\\[(\\d|;)+?m'", ",", "''", ",", "source", ")" ]

[ "Compress", "data", "extraction", "directory", "as", "a", "single", "tar", ".", "gz", "archive" ]

[ "def", "generate_compressed_file", "(", "input_path", ",", "input_name", ",", "output_path", ",", "compressed_file", "=", "'sensor_data'", ")", ":", "cwd_path", "=", "os", ".", "getcwd", "(", ")", "os", ".", "chdir", "(", "input_path", ")", "shutil", ".", "make_archive", "(", "base_name", "=", "os", ".", "path", ".", "join", "(", "output_path", ",", "compressed_file", ")", ",", "format", "=", "'gztar'", ",", "root_dir", "=", "input_path", ",", "base_dir", "=", "input_name", ")", "os", ".", "chdir", "(", "cwd_path", ")" ]

[ "Send", "data", "to", "realplexor", ".", "Throw", "Dklab_Realplexor_Exception", "in", "case", "of", "error", "." ]

[ "def", "send", "(", "self", ",", "idsAndCursors", ",", "data", ",", "showOnlyForIds", "=", "None", ")", ":", "data", "=", "json", ".", "dumps", "(", "data", ")", "pairs", "=", "[", "]", "for", "id", "in", "idsAndCursors", ":", "if", "type", "(", "id", ")", "==", "type", "(", "1", ")", ":", "id", "=", "cursor", "# this is NOT cursor, but ID!", "cursor", "=", "None", "if", "re", ".", "search", "(", "'^\\w+$'", ",", "id", ")", "is", "None", ":", "raise", "Dklab_Realplexor_Exception", "(", "\"Identifier must be alphanumeric, \\\"%s\\\" given\"", "%", "id", ")", "try", ":", "cursor", "=", "idsAndCursors", "[", "id", "]", "except", ":", "cursor", "=", "None", "id", "=", "(", "self", ".", "_namespace", "or", "''", ")", "+", "id", "if", "cursor", "is", "not", "None", ":", "try", ":", "i", "=", "float", "(", "cursor", ")", "except", "ValueError", ":", "raise", "Dklab_Realplexor_Exception", "(", "\"Cursor must be numeric, \\\"%s\\\" given\"", "%", "cursor", ")", "pairs", ".", "append", "(", "\"%s:%s\"", "%", "(", "cursor", ",", "id", ")", ")", "else", ":", "pairs", ".", "append", "(", "id", ")", "if", "isinstance", "(", "showOnlyForIds", ",", "(", "list", ",", "tuple", ")", ")", ":", "for", "id", "in", "showOnlyForIds", ":", "pairs", ".", "append", "(", "\"*\"", "+", "(", "self", ".", "_namespace", "or", "''", ")", "+", "id", ")", "self", ".", "_send", "(", "\",\"", ".", "join", "(", "pairs", ")", ",", "data", ")" ]