Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Normalizes", "a", "list", "of", "arguments", "containing", "one", "or", "more", "strings", "and", "CommandWrapper", "instances", "into", "a", "one", "-", "dimensional", "list", "of", "strings", "." ]

[ "def", "_normalize_args", "(", "args", ")", ":", "if", "isinstance", "(", "args", ",", "six", ".", "string_types", ")", ":", "return", "shlex", ".", "split", "(", "args", ")", "def", "normalize_arg", "(", "arg", ")", ":", "arg", "=", "_convert_pathlib_path", "(", "arg", ")", "if", "isinstance", "(", "arg", ",", "six", ".", "string_types", ")", ":", "return", "[", "six", ".", "text_type", "(", "arg", ")", "]", "if", "isinstance", "(", "arg", ",", "AbstractWrapper", ")", ":", "return", "list", "(", "map", "(", "_convert_pathlib_path", ",", "arg", ".", "command", ")", ")", "raise", "ValueError", "(", "'Invalid argument type: {}'", ".", "format", "(", "type", "(", "arg", ")", ".", "__name__", ")", ")", "if", "isinstance", "(", "args", ",", "AbstractWrapper", ")", ":", "return", "normalize_arg", "(", "args", ")", "return", "list", "(", "_flatmap", "(", "normalize_arg", ",", "args", ")", ")" ]

[ "Lock", "the", "mailbox", "." ]

[ "def", "lock", "(", "self", ")", ":", "if", "not", "self", ".", "_locked", ":", "_lock_file", "(", "self", ".", "_file", ")", "self", ".", "_locked", "=", "True" ]

[ "r", "Raises", "UpgradeHelper", "when", "a", "method", "has", "been", "renamed", "." ]

[ "def", "_filter_renamed_methods", "(", "compute", ",", "method", ")", ":", "if", "method", "==", "\"dcft\"", ":", "raise", "UpgradeHelper", "(", "compute", "+", "\"('dcft')\"", ",", "compute", "+", "\"('dct')\"", ",", "1.4", ",", "\" All instances of 'dcft' should be replaced with 'dct'.\"", ")" ]

[ "Dump", "message", "contents", "to", "target", "file", "." ]

[ "def", "_dump_message", "(", "self", ",", "message", ",", "target", ",", "mangle_from_", "=", "False", ")", ":", "# Most files are opened in binary mode to allow predictable seeking.", "# To get native line endings on disk, the user-friendly \\n line endings", "# used in strings and by email.Message are translated here.", "if", "isinstance", "(", "message", ",", "email", ".", "message", ".", "Message", ")", ":", "buffer", "=", "StringIO", ".", "StringIO", "(", ")", "gen", "=", "email", ".", "generator", ".", "Generator", "(", "buffer", ",", "mangle_from_", ",", "0", ")", "gen", ".", "flatten", "(", "message", ")", "buffer", ".", "seek", "(", "0", ")", "target", ".", "write", "(", "buffer", ".", "read", "(", ")", ".", "replace", "(", "'\\n'", ",", "os", ".", "linesep", ")", ")", "elif", "isinstance", "(", "message", ",", "str", ")", ":", "if", "mangle_from_", ":", "message", "=", "message", ".", "replace", "(", "'\\nFrom '", ",", "'\\n>From '", ")", "message", "=", "message", ".", "replace", "(", "'\\n'", ",", "os", ".", "linesep", ")", "target", ".", "write", "(", "message", ")", "elif", "hasattr", "(", "message", ",", "'read'", ")", ":", "while", "True", ":", "line", "=", "message", ".", "readline", "(", ")", "if", "line", "==", "''", ":", "break", "if", "mangle_from_", "and", "line", ".", "startswith", "(", "'From '", ")", ":", "line", "=", "'>From '", "+", "line", "[", "5", ":", "]", "line", "=", "line", ".", "replace", "(", "'\\n'", ",", "os", ".", "linesep", ")", "target", ".", "write", "(", "line", ")", "else", ":", "raise", "TypeError", "(", "'Invalid message type: %s'", "%", "type", "(", "message", ")", ")" ]

[ "Return", "a", "comma", "-", "separated", "list", "of", "option", "strings", "&", "metavariables", "." ]

[ "def", "format_option_strings", "(", "self", ",", "option", ")", ":", "if", "option", ".", "takes_value", "(", ")", ":", "metavar", "=", "option", ".", "metavar", "or", "option", ".", "dest", ".", "upper", "(", ")", "short_opts", "=", "[", "self", ".", "_short_opt_fmt", "%", "(", "sopt", ",", "metavar", ")", "for", "sopt", "in", "option", ".", "_short_opts", "]", "long_opts", "=", "[", "self", ".", "_long_opt_fmt", "%", "(", "lopt", ",", "metavar", ")", "for", "lopt", "in", "option", ".", "_long_opts", "]", "else", ":", "short_opts", "=", "option", ".", "_short_opts", "long_opts", "=", "option", ".", "_long_opts", "if", "self", ".", "short_first", ":", "opts", "=", "short_opts", "+", "long_opts", "else", ":", "opts", "=", "long_opts", "+", "short_opts", "return", "\", \"", ".", "join", "(", "opts", ")" ]

[ "Returns", "the", "list", "of", "preprocessor", "definitions", "for", "this", "configuation", "." ]

[ "def", "_GetDefines", "(", "config", ")", ":", "defines", "=", "[", "]", "for", "d", "in", "config", ".", "get", "(", "'defines'", ",", "[", "]", ")", ":", "if", "type", "(", "d", ")", "==", "list", ":", "fd", "=", "'='", ".", "join", "(", "[", "str", "(", "dpart", ")", "for", "dpart", "in", "d", "]", ")", "else", ":", "fd", "=", "str", "(", "d", ")", "defines", ".", "append", "(", "fd", ")", "return", "defines" ]

[ "Loads", "the", "named", "descriptor", "from", "the", "pool", "." ]

[ "def", "FindMessageTypeByName", "(", "self", ",", "full_name", ")", ":", "full_name", "=", "_NormalizeFullyQualifiedName", "(", "full_name", ")", "if", "full_name", "not", "in", "self", ".", "_descriptors", ":", "self", ".", "_FindFileContainingSymbolInDb", "(", "full_name", ")", "return", "self", ".", "_descriptors", "[", "full_name", "]" ]

[]

[ "def", "setDebugActions", "(", "self", ",", "startAction", ",", "successAction", ",", "exceptionAction", ")", ":", "self", ".", "debugActions", "=", "(", "startAction", "or", "_defaultStartDebugAction", ",", "successAction", "or", "_defaultSuccessDebugAction", ",", "exceptionAction", "or", "_defaultExceptionDebugAction", ")", "self", ".", "debug", "=", "True", "return", "self" ]

[ "Quick", "and", "dirty", "utilities", "for", "checking", "library", "linkage", "." ]

[ "def", "linking", "(", "obj", ")", ":", "pass" ]

[ "Initial", "the", "dispatch", "tables", "for", "special", "handling", "of", "special", "construction", "variables", "." ]

[ "def", "_init_special", "(", "self", ")", ":", "self", ".", "_special_del", "=", "{", "}", "self", ".", "_special_del", "[", "'SCANNERS'", "]", "=", "_del_SCANNERS", "self", ".", "_special_set", "=", "{", "}", "for", "key", "in", "reserved_construction_var_names", ":", "self", ".", "_special_set", "[", "key", "]", "=", "_set_reserved", "for", "key", "in", "future_reserved_construction_var_names", ":", "self", ".", "_special_set", "[", "key", "]", "=", "_set_future_reserved", "self", ".", "_special_set", "[", "'BUILDERS'", "]", "=", "_set_BUILDERS", "self", ".", "_special_set", "[", "'SCANNERS'", "]", "=", "_set_SCANNERS", "# Freeze the keys of self._special_set in a list for use by", "# methods that need to check. (Empirically, list scanning has", "# gotten better than dict.has_key() in Python 2.5.)", "self", ".", "_special_set_keys", "=", "list", "(", "self", ".", "_special_set", ".", "keys", "(", ")", ")" ]

[ "Reset", "the", "iterator", "to", "the", "begin", "of", "the", "data", "." ]

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

[ "Parse", "a", "given", "node", ".", "This", "function", "in", "turn", "calls", "the", "parse_<nodeType", ">", "functions", "which", "handle", "the", "respective", "nodes", "." ]

[ "def", "parse", "(", "self", ",", "node", ")", ":", "pm", "=", "getattr", "(", "self", ",", "\"parse_%s\"", "%", "node", ".", "__class__", ".", "__name__", ")", "pm", "(", "node", ")" ]

[ "Retrieve", "the", "cursor", "that", "represents", "the", "given", "translation", "unit", "." ]

[ "def", "cursor", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getTranslationUnitCursor", "(", "self", ")" ]

[ "Divide", "pv", "instance", "and", "convey", "it", "to", "input_channel", "." ]

[ "def", "postprocess_instance", "(", "self", ")", ":", "self", ".", "dataset", ".", "postprocess_instance", "(", ")" ]

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

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

[ "Take", "out", "each", "index", "subscript", "vector", "of", "the", "dim", "dimension", "and", "add", "the", "corresponding", "tensor", "variable", ".", "Example", ":" ]

[ "def", "index_add_", "(", "x", ",", "dim", ",", "index", ",", "tensor", ")", ":", "assert", "len", "(", "index", ".", "shape", ")", "==", "1", "assert", "tensor", ".", "shape", "[", "0", "]", "==", "index", ".", "shape", "[", "0", "]", "x", "[", "(", "slice", "(", "None", ",", ")", ",", ")", "*", "dim", "+", "(", "index", ",", ")", "]", "+=", "tensor" ]

[ "Given", "a", "FunctionPageInfo", "object", "Return", "the", "page", "as", "an", "md", "string", "." ]

[ "def", "_build_function_page", "(", "page_info", ")", ":", "parts", "=", "[", "_Metadata", "(", "page_info", ".", "full_name", ")", ".", "build_html", "(", ")", "]", "parts", ".", "append", "(", "'# %s\\n\\n'", "%", "page_info", ".", "full_name", ")", "if", "len", "(", "page_info", ".", "aliases", ")", ">", "1", ":", "parts", ".", "append", "(", "'### Aliases:\\n\\n'", ")", "parts", ".", "extend", "(", "'* `%s`\\n'", "%", "name", "for", "name", "in", "page_info", ".", "aliases", ")", "parts", ".", "append", "(", "'\\n'", ")", "if", "page_info", ".", "signature", "is", "not", "None", ":", "parts", ".", "append", "(", "_build_signature", "(", "page_info", ")", ")", "if", "page_info", ".", "defined_in", ":", "parts", ".", "append", "(", "'\\n\\n'", ")", "parts", ".", "append", "(", "str", "(", "page_info", ".", "defined_in", ")", ")", "parts", ".", "append", "(", "page_info", ".", "guides", ")", "parts", ".", "append", "(", "page_info", ".", "doc", ".", "docstring", ")", "parts", ".", "append", "(", "_build_function_details", "(", "page_info", ".", "doc", ".", "function_details", ")", ")", "parts", ".", "append", "(", "_build_compatibility", "(", "page_info", ".", "doc", ".", "compatibility", ")", ")", "return", "''", ".", "join", "(", "parts", ")" ]

[ "Generate", "package", "__config__", ".", "py", "file", "containing", "system_info", "information", "used", "during", "building", "the", "package", "." ]

[ "def", "make_config_py", "(", "self", ",", "name", "=", "'__config__'", ")", ":", "self", ".", "py_modules", ".", "append", "(", "(", "self", ".", "name", ",", "name", ",", "generate_config_py", ")", ")" ]

[ "Iterate", "over", "DataFrame", "rows", "as", "namedtuples", "." ]

[ "def", "itertuples", "(", "self", ",", "index", ":", "bool", "=", "True", ",", "name", ":", "str", "|", "None", "=", "\"Pandas\"", ")", "->", "Iterable", "[", "tuple", "[", "Any", ",", "...", "]", "]", ":", "arrays", "=", "[", "]", "fields", "=", "list", "(", "self", ".", "columns", ")", "if", "index", ":", "arrays", ".", "append", "(", "self", ".", "index", ")", "fields", ".", "insert", "(", "0", ",", "\"Index\"", ")", "# use integer indexing because of possible duplicate column names", "arrays", ".", "extend", "(", "self", ".", "iloc", "[", ":", ",", "k", "]", "for", "k", "in", "range", "(", "len", "(", "self", ".", "columns", ")", ")", ")", "if", "name", "is", "not", "None", ":", "# https://github.com/python/mypy/issues/9046", "# error: namedtuple() expects a string literal as the first argument", "itertuple", "=", "collections", ".", "namedtuple", "(", "# type: ignore[misc]", "name", ",", "fields", ",", "rename", "=", "True", ")", "return", "map", "(", "itertuple", ".", "_make", ",", "zip", "(", "*", "arrays", ")", ")", "# fallback to regular tuples", "return", "zip", "(", "*", "arrays", ")" ]

[ "An", "emitter", "for", "TeX", "and", "LaTeX", "sources", "when", "executing", "pdftex", "or", "pdflatex", ".", "It", "will", "accept", "graphics", "files", "of", "types", ".", "pdf", ".", "jpg", ".", "png", ".", "gif", "and", ".", "tif" ]

[ "def", "tex_pdf_emitter", "(", "target", ",", "source", ",", "env", ")", ":", "(", "target", ",", "source", ")", "=", "tex_emitter_core", "(", "target", ",", "source", ",", "env", ",", "LatexGraphics", ")", "return", "(", "target", ",", "source", ")" ]

[ "Calculates", "delay", "based", "on", "exponential", "backoff", "." ]

[ "def", "delay_amount", "(", "self", ",", "context", ")", ":", "# The context.attempt_number is a 1-based value, but we have", "# to calculate the delay based on i based a 0-based value. We", "# want the first delay to just be ``rand(0, 1)``.", "return", "min", "(", "self", ".", "_random", "(", ")", "*", "(", "self", ".", "_base", "**", "(", "context", ".", "attempt_number", "-", "1", ")", ")", ",", "self", ".", "_max_backoff", ")" ]

[ "Return", "the", "absolute", "path", "to", "depth", "i", "in", "the", "image", "sequence", "." ]

[ "def", "depth_path_at", "(", "self", ",", "i", ")", ":", "return", "self", ".", "depth_path_from_index", "(", "self", ".", "image_index", "[", "i", "]", ")" ]

[ "Return", "the", "current", "item", "then", "advance", ":", "attr", ":", "current", "to", "the", "next", "item", "." ]

[ "def", "next", "(", "self", ")", "->", "t", ".", "Any", ":", "rv", "=", "self", ".", "current", "self", ".", "pos", "=", "(", "self", ".", "pos", "+", "1", ")", "%", "len", "(", "self", ".", "items", ")", "return", "rv" ]

[ "Conjoin", "clause", "sets", "taking", "into", "account", "skolems" ]

[ "def", "conjoin", "(", "clauses1", ",", "clauses2", ",", "annot_op", "=", "None", ")", ":", "return", "and_clauses", "(", "clauses1", ",", "rename_distinct", "(", "clauses2", ",", "clauses1", ")", ",", "annot_op", "=", "annot_op", ")" ]

[ "Rewards", "for", "all", "players", "." ]

[ "def", "rewards", "(", "self", ")", "->", "List", "[", "float", "]", ":", "# For now, only single-population (single-player) mean field games", "# are supported.", "return", "[", "self", ".", "_rewards", "(", ")", "]" ]

[ "Converts", "a", "C", "pre", "-", "processor", "expression", "into", "an", "equivalent", "Python", "expression", "that", "can", "be", "evaluated", "." ]

[ "def", "CPP_to_Python", "(", "s", ")", ":", "s", "=", "CPP_to_Python_Ops_Expression", ".", "sub", "(", "CPP_to_Python_Ops_Sub", ",", "s", ")", "for", "expr", ",", "repl", "in", "CPP_to_Python_Eval_List", ":", "s", "=", "expr", ".", "sub", "(", "repl", ",", "s", ")", "return", "s" ]

[ "Init", "setup", ":", "return", ":" ]

[ "def", "setup", "(", "self", ")", ":", "self", ".", "init_setup", "(", "UBMatrixPeakTable", ".", "UB_Peak_Table_Setup", ")", "self", ".", "set_status_column_name", "(", "'Selected'", ")", "# define all the _colIndex", "self", ".", "_colIndexScan", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Scan'", ")", "self", ".", "_colIndexSpiceHKL", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Spice HKL'", ")", "self", ".", "_colIndexCalculatedHKL", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Calculated HKL'", ")", "self", ".", "_colIndexQSample", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Q-Sample'", ")", "self", ".", "_colIndexWavelength", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Wavelength'", ")", "self", ".", "_colIndexError", "=", "self", ".", "_myColumnNameList", ".", "index", "(", "'Error'", ")", "# set up the width of some columns", "self", ".", "setColumnWidth", "(", "self", ".", "_colIndexSpiceHKL", ",", "240", ")", "self", ".", "setColumnWidth", "(", "self", ".", "_colIndexCalculatedHKL", ",", "240", ")", "self", ".", "setColumnWidth", "(", "4", ",", "240", ")", "return" ]

[ "Converts", "value", "to", "str", "if", "it", "is", "not", "." ]

[ "def", "_StrConvert", "(", "value", ")", ":", "# This file is imported by c extension and some methods like ClearField", "# requires string for the field name. py2/py3 has different text", "# type and may use unicode.", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", ".", "encode", "(", "'utf-8'", ")", "return", "value" ]

[ "Serialization", "composite", "code", "generator", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", "Generates", "main", "source", "code", "files", "for", "composite", "deserializers", ".", "The", "files", "are", "generated", "as", "they", "are", "extremely", "repetitive", "(", "composite", "deserializer", "for", "0", "..", "9", "sub", "-", "deserializers", ")", "." ]

[ "def", "main", "(", ")", ":", "serialization_composite_h_file", "=", "os", ".", "path", ".", "abspath", "(", "sys", ".", "argv", "[", "1", "]", ")", "generator", ".", "generate_main_code", "(", "serialization_composite_h_file", ")" ]

[ "TimeSpan_Millisecond", "()", "-", ">", "TimeSpan" ]

[ "def", "TimeSpan_Millisecond", "(", "*", "args", ")", ":", "return", "_misc_", ".", "TimeSpan_Millisecond", "(", "*", "args", ")" ]

[ "Generate", "rank", ".", "conf" ]

[ "def", "generate_rank_conf", "(", ")", ":", "print", "(", "'generating rank conf...'", ")", "with", "open", "(", "'./conf_templates/rank.conf.template'", ")", "as", "fin", ",", "open", "(", "'rank.conf'", ",", "'w'", ")", "as", "fout", ":", "skill_rank", "=", "'\\n'", ".", "join", "(", "[", "' order: \"{}\"'", ".", "format", "(", "x", ")", "for", "x", "in", "options", "[", "'skill_rank'", "]", "]", ")", "template", "=", "ConfTemplate", "(", "fin", ".", "read", "(", ")", ")", "print", "(", "template", ".", "substitute", "(", "{", "'skill_rank'", ":", "skill_rank", "}", ")", ",", "file", "=", "fout", ")" ]

[ "Interpolate", "the", "function", "." ]

[ "def", "__call__", "(", "self", ",", "x", ",", "y", ",", "dx", "=", "0", ",", "dy", "=", "0", ",", "assume_sorted", "=", "False", ")", ":", "x", "=", "atleast_1d", "(", "x", ")", "y", "=", "atleast_1d", "(", "y", ")", "if", "x", ".", "ndim", "!=", "1", "or", "y", ".", "ndim", "!=", "1", ":", "raise", "ValueError", "(", "\"x and y should both be 1-D arrays\"", ")", "if", "not", "assume_sorted", ":", "x", "=", "np", ".", "sort", "(", "x", ")", "y", "=", "np", ".", "sort", "(", "y", ")", "if", "self", ".", "bounds_error", "or", "self", ".", "fill_value", "is", "not", "None", ":", "out_of_bounds_x", "=", "(", "x", "<", "self", ".", "x_min", ")", "|", "(", "x", ">", "self", ".", "x_max", ")", "out_of_bounds_y", "=", "(", "y", "<", "self", ".", "y_min", ")", "|", "(", "y", ">", "self", ".", "y_max", ")", "any_out_of_bounds_x", "=", "np", ".", "any", "(", "out_of_bounds_x", ")", "any_out_of_bounds_y", "=", "np", ".", "any", "(", "out_of_bounds_y", ")", "if", "self", ".", "bounds_error", "and", "(", "any_out_of_bounds_x", "or", "any_out_of_bounds_y", ")", ":", "raise", "ValueError", "(", "\"Values out of range; x must be in %r, y in %r\"", "%", "(", "(", "self", ".", "x_min", ",", "self", ".", "x_max", ")", ",", "(", "self", ".", "y_min", ",", "self", ".", "y_max", ")", ")", ")", "z", "=", "fitpack", ".", "bisplev", "(", "x", ",", "y", ",", "self", ".", "tck", ",", "dx", ",", "dy", ")", "z", "=", "atleast_2d", "(", "z", ")", "z", "=", "transpose", "(", "z", ")", "if", "self", ".", "fill_value", "is", "not", "None", ":", "if", "any_out_of_bounds_x", ":", "z", "[", ":", ",", "out_of_bounds_x", "]", "=", "self", ".", "fill_value", "if", "any_out_of_bounds_y", ":", "z", "[", "out_of_bounds_y", ",", ":", "]", "=", "self", ".", "fill_value", "if", "len", "(", "z", ")", "==", "1", ":", "z", "=", "z", "[", "0", "]", "return", "array", "(", "z", ")" ]

[ "Update", "dictionary", "with", "contents", "of", "another", "dictionary" ]

[ "def", "_add_to_dict", "(", "cls", ",", "src_dict", ",", "dest_dict", ")", ":", "if", "src_dict", ":", "for", "k", ",", "v", "in", "src_dict", ".", "items", "(", ")", ":", "if", "k", "in", "dest_dict", ":", "if", "(", "isinstance", "(", "dest_dict", "[", "k", "]", ",", "Iterable", ")", "and", "isinstance", "(", "v", ",", "Iterable", ")", ")", ":", "dest_dict", "[", "k", "]", "+=", "v", "elif", "isinstance", "(", "dest_dict", "[", "k", "]", ",", "Iterable", ")", ":", "dest_dict", "[", "k", "]", ".", "append", "(", "v", ")", "else", ":", "dest_dict", "[", "k", "]", "=", "v", "else", ":", "dest_dict", "[", "k", "]", "=", "v", "return", "dest_dict" ]

[ ":", "param", "change_dct", ":", "dict", "(", "old_path", "=", "(", "new_path", "old_lines", "new_lines", "))" ]

[ "def", "__init__", "(", "self", ",", "change_dct", ")", ":", "self", ".", "change_dct", "=", "change_dct" ]

[ "Return", "the", "last", "modification", "time", "of", "the", "file", "." ]

[ "def", "time", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getFileTime", "(", "self", ")" ]

[ "Create", "new", "TransientShardState", "from", "webapp", "request", "." ]

[ "def", "from_request", "(", "cls", ",", "request", ")", ":", "mapreduce_spec", "=", "MapreduceSpec", ".", "from_json_str", "(", "request", ".", "get", "(", "\"mapreduce_spec\"", ")", ")", "mapper_spec", "=", "mapreduce_spec", ".", "mapper", "input_reader_spec_dict", "=", "json", ".", "loads", "(", "request", ".", "get", "(", "\"input_reader_state\"", ")", ",", "cls", "=", "json_util", ".", "JsonDecoder", ")", "input_reader", "=", "mapper_spec", ".", "input_reader_class", "(", ")", ".", "from_json", "(", "input_reader_spec_dict", ")", "initial_input_reader_spec_dict", "=", "json", ".", "loads", "(", "request", ".", "get", "(", "\"initial_input_reader_state\"", ")", ",", "cls", "=", "json_util", ".", "JsonDecoder", ")", "initial_input_reader", "=", "mapper_spec", ".", "input_reader_class", "(", ")", ".", "from_json", "(", "initial_input_reader_spec_dict", ")", "output_writer", "=", "None", "if", "mapper_spec", ".", "output_writer_class", "(", ")", ":", "output_writer", "=", "mapper_spec", ".", "output_writer_class", "(", ")", ".", "from_json", "(", "json", ".", "loads", "(", "request", ".", "get", "(", "\"output_writer_state\"", ",", "\"{}\"", ")", ",", "cls", "=", "json_util", ".", "JsonDecoder", ")", ")", "assert", "isinstance", "(", "output_writer", ",", "mapper_spec", ".", "output_writer_class", "(", ")", ")", ",", "(", "\"%s.from_json returned an instance of wrong class: %s\"", "%", "(", "mapper_spec", ".", "output_writer_class", "(", ")", ",", "output_writer", ".", "__class__", ")", ")", "handler", "=", "util", ".", "try_deserialize_handler", "(", "request", ".", "get", "(", "\"serialized_handler\"", ")", ")", "if", "not", "handler", ":", "handler", "=", "mapreduce_spec", ".", "mapper", ".", "handler", "return", "cls", "(", "mapreduce_spec", ".", "params", "[", "\"base_path\"", "]", ",", "mapreduce_spec", ",", "str", "(", "request", ".", "get", "(", "\"shard_id\"", ")", ")", ",", "int", "(", "request", ".", "get", "(", "\"slice_id\"", ")", ")", ",", "input_reader", ",", "initial_input_reader", ",", "output_writer", "=", "output_writer", ",", "retries", "=", "int", "(", "request", ".", "get", "(", "\"retries\"", ")", ")", ",", "handler", "=", "handler", ")" ]

[ "Dict", "-", "like", "itervalues", "()", "that", "returns", "an", "iterator", "of", "values", "of", "cookies", "from", "the", "jar", "." ]

[ "def", "itervalues", "(", "self", ")", ":", "for", "cookie", "in", "iter", "(", "self", ")", ":", "yield", "cookie", ".", "value" ]

[ "Customize", "Fortran", "compiler", "." ]

[ "def", "customize", "(", "self", ",", "dist", "=", "None", ")", ":", "log", ".", "info", "(", "'customize %s'", "%", "(", "self", ".", "__class__", ".", "__name__", ")", ")", "self", ".", "_is_customised", "=", "True", "self", ".", "distutils_vars", ".", "use_distribution", "(", "dist", ")", "self", ".", "command_vars", ".", "use_distribution", "(", "dist", ")", "self", ".", "flag_vars", ".", "use_distribution", "(", "dist", ")", "self", ".", "update_executables", "(", ")", "# find_executables takes care of setting the compiler commands,", "# version_cmd, linker_so, linker_exe, ar, and ranlib", "self", ".", "find_executables", "(", ")", "noopt", "=", "self", ".", "distutils_vars", ".", "get", "(", "'noopt'", ",", "False", ")", "noarch", "=", "self", ".", "distutils_vars", ".", "get", "(", "'noarch'", ",", "noopt", ")", "debug", "=", "self", ".", "distutils_vars", ".", "get", "(", "'debug'", ",", "False", ")", "f77", "=", "self", ".", "command_vars", ".", "compiler_f77", "f90", "=", "self", ".", "command_vars", ".", "compiler_f90", "f77flags", "=", "[", "]", "f90flags", "=", "[", "]", "freeflags", "=", "[", "]", "fixflags", "=", "[", "]", "if", "f77", ":", "f77", "=", "_shell_utils", ".", "NativeParser", ".", "split", "(", "f77", ")", "f77flags", "=", "self", ".", "flag_vars", ".", "f77", "if", "f90", ":", "f90", "=", "_shell_utils", ".", "NativeParser", ".", "split", "(", "f90", ")", "f90flags", "=", "self", ".", "flag_vars", ".", "f90", "freeflags", "=", "self", ".", "flag_vars", ".", "free", "# XXX Assuming that free format is default for f90 compiler.", "fix", "=", "self", ".", "command_vars", ".", "compiler_fix", "# NOTE: this and similar examples are probably just", "# excluding --coverage flag when F90 = gfortran --coverage", "# instead of putting that flag somewhere more appropriate", "# this and similar examples where a Fortran compiler", "# environment variable has been customized by CI or a user", "# should perhaps eventually be more thoroughly tested and more", "# robustly handled", "if", "fix", ":", "fix", "=", "_shell_utils", ".", "NativeParser", ".", "split", "(", "fix", ")", "fixflags", "=", "self", ".", "flag_vars", ".", "fix", "+", "f90flags", "oflags", ",", "aflags", ",", "dflags", "=", "[", "]", ",", "[", "]", ",", "[", "]", "# examine get_flags_<tag>_<compiler> for extra flags", "# only add them if the method is different from get_flags_<tag>", "def", "get_flags", "(", "tag", ",", "flags", ")", ":", "# note that self.flag_vars.<tag> calls self.get_flags_<tag>()", "flags", ".", "extend", "(", "getattr", "(", "self", ".", "flag_vars", ",", "tag", ")", ")", "this_get", "=", "getattr", "(", "self", ",", "'get_flags_'", "+", "tag", ")", "for", "name", ",", "c", ",", "flagvar", "in", "[", "(", "'f77'", ",", "f77", ",", "f77flags", ")", ",", "(", "'f90'", ",", "f90", ",", "f90flags", ")", ",", "(", "'f90'", ",", "fix", ",", "fixflags", ")", "]", ":", "t", "=", "'%s_%s'", "%", "(", "tag", ",", "name", ")", "if", "c", "and", "this_get", "is", "not", "getattr", "(", "self", ",", "'get_flags_'", "+", "t", ")", ":", "flagvar", ".", "extend", "(", "getattr", "(", "self", ".", "flag_vars", ",", "t", ")", ")", "if", "not", "noopt", ":", "get_flags", "(", "'opt'", ",", "oflags", ")", "if", "not", "noarch", ":", "get_flags", "(", "'arch'", ",", "aflags", ")", "if", "debug", ":", "get_flags", "(", "'debug'", ",", "dflags", ")", "fflags", "=", "self", ".", "flag_vars", ".", "flags", "+", "dflags", "+", "oflags", "+", "aflags", "if", "f77", ":", "self", ".", "set_commands", "(", "compiler_f77", "=", "f77", "+", "f77flags", "+", "fflags", ")", "if", "f90", ":", "self", ".", "set_commands", "(", "compiler_f90", "=", "f90", "+", "freeflags", "+", "f90flags", "+", "fflags", ")", "if", "fix", ":", "self", ".", "set_commands", "(", "compiler_fix", "=", "fix", "+", "fixflags", "+", "fflags", ")", "#XXX: Do we need LDSHARED->SOSHARED, LDFLAGS->SOFLAGS", "linker_so", "=", "self", ".", "linker_so", "if", "linker_so", ":", "linker_so_flags", "=", "self", ".", "flag_vars", ".", "linker_so", "if", "sys", ".", "platform", ".", "startswith", "(", "'aix'", ")", ":", "python_lib", "=", "get_python_lib", "(", "standard_lib", "=", "1", ")", "ld_so_aix", "=", "os", ".", "path", ".", "join", "(", "python_lib", ",", "'config'", ",", "'ld_so_aix'", ")", "python_exp", "=", "os", ".", "path", ".", "join", "(", "python_lib", ",", "'config'", ",", "'python.exp'", ")", "linker_so", "=", "[", "ld_so_aix", "]", "+", "linker_so", "+", "[", "'-bI:'", "+", "python_exp", "]", "self", ".", "set_commands", "(", "linker_so", "=", "linker_so", "+", "linker_so_flags", ")", "linker_exe", "=", "self", ".", "linker_exe", "if", "linker_exe", ":", "linker_exe_flags", "=", "self", ".", "flag_vars", ".", "linker_exe", "self", ".", "set_commands", "(", "linker_exe", "=", "linker_exe", "+", "linker_exe_flags", ")", "ar", "=", "self", ".", "command_vars", ".", "archiver", "if", "ar", ":", "arflags", "=", "self", ".", "flag_vars", ".", "ar", "self", ".", "set_commands", "(", "archiver", "=", "[", "ar", "]", "+", "arflags", ")", "self", ".", "set_library_dirs", "(", "self", ".", "get_library_dirs", "(", ")", ")", "self", ".", "set_libraries", "(", "self", ".", "get_libraries", "(", ")", ")" ]

[ "r", "Convert", "paths", "using", "native", "DOS", "format", "like", ":", "\\", "Device", "\\", "HarddiskVolume1", "\\", "Windows", "\\", "systemew", "\\", "file", ".", "txt", "into", ":", "C", ":", "\\", "Windows", "\\", "systemew", "\\", "file", ".", "txt" ]

[ "def", "convert_dos_path", "(", "s", ")", ":", "rawdrive", "=", "'\\\\'", ".", "join", "(", "s", ".", "split", "(", "'\\\\'", ")", "[", ":", "3", "]", ")", "driveletter", "=", "cext", ".", "win32_QueryDosDevice", "(", "rawdrive", ")", "remainder", "=", "s", "[", "len", "(", "rawdrive", ")", ":", "]", "return", "os", ".", "path", ".", "join", "(", "driveletter", ",", "remainder", ")" ]

[ "Generate", "a", "list", "of", "Python", "Decimals", "with", "*", "none_prob", "*", "probability", "of", "an", "entry", "being", "None", "(", "or", "NaN", "if", "*", "use_nan", "*", "is", "true", ")", "." ]

[ "def", "generate_decimal_list", "(", "self", ",", "n", ",", "none_prob", "=", "DEFAULT_NONE_PROB", ",", "use_nan", "=", "False", ")", ":", "data", "=", "[", "decimal", ".", "Decimal", "(", "'%.9f'", "%", "f", ")", "for", "f", "in", "self", ".", "rnd", ".", "uniform", "(", "0.0", ",", "1.0", ",", "n", ")", "]", "assert", "len", "(", "data", ")", "==", "n", "self", ".", "sprinkle", "(", "data", ",", "none_prob", ",", "value", "=", "decimal", ".", "Decimal", "(", "'nan'", ")", "if", "use_nan", "else", "None", ")", "return", "data" ]

[ "Remove", "this", "widget", "from", "parent", "widget", ".", "Remove", "a", "widget", "from", "its", "parent", "before", "deleting", "it", ".", "Overwrite", "this", "to", "also", "remove", "all", "button", "actions", "separately", "with", "a", "call", "to", "<code", ">", "self", ".", "parent", ".", "_removeButtonAction", "()", "<", "/", "code", ">", ".", "This", "is", "not", "done", "in", "the", "destructor", "as", "Python", "s", "garbage", "collector", "does", "not", "guarantee", "to", "delete", "objects", "." ]

[ "def", "removeFromParent", "(", "self", ")", ":", "self", ".", "parent", ".", "_removeWidget", "(", "self", ")", "return" ]

[ "Transmit", "version", "/", "status", "/", "date", "/", "server", "via", "self", ".", "_write", "()" ]

[ "def", "send_preamble", "(", "self", ")", ":", "if", "self", ".", "origin_server", ":", "if", "self", ".", "client_is_modern", "(", ")", ":", "self", ".", "_write", "(", "'HTTP/%s %s\\r\\n'", "%", "(", "self", ".", "http_version", ",", "self", ".", "status", ")", ")", "if", "'Date'", "not", "in", "self", ".", "headers", ":", "self", ".", "_write", "(", "'Date: %s\\r\\n'", "%", "format_date_time", "(", "time", ".", "time", "(", ")", ")", ")", "if", "self", ".", "server_software", "and", "'Server'", "not", "in", "self", ".", "headers", ":", "self", ".", "_write", "(", "'Server: %s\\r\\n'", "%", "self", ".", "server_software", ")", "else", ":", "self", ".", "_write", "(", "'Status: %s\\r\\n'", "%", "self", ".", "status", ")" ]

[ "Flip", "an", "image", "horizontally", "(", "upside", "down", ")", "." ]

[ "def", "flip_up_down", "(", "image", ")", ":", "image", "=", "ops", ".", "convert_to_tensor", "(", "image", ",", "name", "=", "'image'", ")", "_Check3DImage", "(", "image", ",", "require_static", "=", "False", ")", "return", "array_ops", ".", "reverse", "(", "image", ",", "[", "True", ",", "False", ",", "False", "]", ")" ]

[ "Computes", "the", "logistic", "loss", "." ]

[ "def", "_logistic_loss", "(", "w", ",", "X", ",", "y", ",", "alpha", ",", "sample_weight", "=", "None", ")", ":", "w", ",", "c", ",", "yz", "=", "_intercept_dot", "(", "w", ",", "X", ",", "y", ")", "if", "sample_weight", "is", "None", ":", "sample_weight", "=", "np", ".", "ones", "(", "y", ".", "shape", "[", "0", "]", ")", "# Logistic loss is the negative of the log of the logistic function.", "out", "=", "-", "np", ".", "sum", "(", "sample_weight", "*", "log_logistic", "(", "yz", ")", ")", "+", ".5", "*", "alpha", "*", "np", ".", "dot", "(", "w", ",", "w", ")", "return", "out" ]

[ "Create", "a", "group", "." ]

[ "def", "CreateGroup", "(", "self", ",", "group_id", ",", "group_name", ",", "description", ",", "email_permission", ")", ":", "uri", "=", "self", ".", "_ServiceUrl", "(", "'group'", ",", "False", ",", "group_id", ",", "''", ",", "''", ",", "''", ",", "''", ")", "properties", "=", "{", "}", "properties", "[", "'groupId'", "]", "=", "group_id", "properties", "[", "'groupName'", "]", "=", "group_name", "properties", "[", "'description'", "]", "=", "description", "properties", "[", "'emailPermission'", "]", "=", "email_permission", "return", "self", ".", "_PostProperties", "(", "uri", ",", "properties", ")" ]

[ "Return", "True", "if", "connection", "should", "be", "added", "to", "read", "list", "of", "select" ]

[ "def", "is_readable", "(", "self", ")", ":", "return", "self", ".", "status", "in", "(", "WAIT_LEN", ",", "WAIT_MESSAGE", ")" ]

[ "See", "base", "class", "." ]

[ "def", "_get_predict_ops", "(", "self", ",", "features", ")", ":", "self", ".", "_validate_dnn_feature_columns", "(", "features", ")", "return", "super", "(", "DNNRegressor", ",", "self", ")", ".", "_get_predict_ops", "(", "features", ")" ]

[ "Split", "text", "into", "(", "tokentype", "text", ")", "pairs", "." ]

[ "def", "get_tokens_unprocessed", "(", "self", ",", "text", ",", "stack", "=", "(", "'root'", ",", ")", ")", ":", "pos", "=", "0", "tokendefs", "=", "self", ".", "_tokens", "statestack", "=", "list", "(", "stack", ")", "statetokens", "=", "tokendefs", "[", "statestack", "[", "-", "1", "]", "]", "while", "1", ":", "for", "rexmatch", ",", "action", ",", "new_state", "in", "statetokens", ":", "m", "=", "rexmatch", "(", "text", ",", "pos", ")", "if", "m", ":", "if", "action", "is", "not", "None", ":", "if", "type", "(", "action", ")", "is", "_TokenType", ":", "yield", "pos", ",", "action", ",", "m", ".", "group", "(", ")", "else", ":", "yield", "from", "action", "(", "self", ",", "m", ")", "pos", "=", "m", ".", "end", "(", ")", "if", "new_state", "is", "not", "None", ":", "# state transition", "if", "isinstance", "(", "new_state", ",", "tuple", ")", ":", "for", "state", "in", "new_state", ":", "if", "state", "==", "'#pop'", ":", "if", "len", "(", "statestack", ")", ">", "1", ":", "statestack", ".", "pop", "(", ")", "elif", "state", "==", "'#push'", ":", "statestack", ".", "append", "(", "statestack", "[", "-", "1", "]", ")", "else", ":", "statestack", ".", "append", "(", "state", ")", "elif", "isinstance", "(", "new_state", ",", "int", ")", ":", "# pop, but keep at least one state on the stack", "# (random code leading to unexpected pops should", "# not allow exceptions)", "if", "abs", "(", "new_state", ")", ">=", "len", "(", "statestack", ")", ":", "del", "statestack", "[", "1", ":", "]", "else", ":", "del", "statestack", "[", "new_state", ":", "]", "elif", "new_state", "==", "'#push'", ":", "statestack", ".", "append", "(", "statestack", "[", "-", "1", "]", ")", "else", ":", "assert", "False", ",", "\"wrong state def: %r\"", "%", "new_state", "statetokens", "=", "tokendefs", "[", "statestack", "[", "-", "1", "]", "]", "break", "else", ":", "# We are here only if all state tokens have been considered", "# and there was not a match on any of them.", "try", ":", "if", "text", "[", "pos", "]", "==", "'\\n'", ":", "# at EOL, reset state to \"root\"", "statestack", "=", "[", "'root'", "]", "statetokens", "=", "tokendefs", "[", "'root'", "]", "yield", "pos", ",", "Text", ",", "'\\n'", "pos", "+=", "1", "continue", "yield", "pos", ",", "Error", ",", "text", "[", "pos", "]", "pos", "+=", "1", "except", "IndexError", ":", "break" ]

[ "r", "Ensure", "that", "option", "is", "a", "list", "of", "strings", ".", "If", "option", "is", "currently", "a", "string", "we", "split", "it", "either", "on", "/", "\\", "s", "*", "/", "or", "/", "\\", "s", "+", "/", "so", "foo", "bar", "baz", "foo", "bar", "baz", "and", "foo", "bar", "baz", "all", "become", "[", "foo", "bar", "baz", "]", "." ]

[ "def", "ensure_string_list", "(", "self", ",", "option", ")", ":", "val", "=", "getattr", "(", "self", ",", "option", ")", "if", "val", "is", "None", ":", "return", "elif", "isinstance", "(", "val", ",", "string_types", ")", ":", "setattr", "(", "self", ",", "option", ",", "re", ".", "split", "(", "r',\\s*|\\s+'", ",", "val", ")", ")", "else", ":", "if", "isinstance", "(", "val", ",", "list", ")", ":", "ok", "=", "all", "(", "isinstance", "(", "v", ",", "string_types", ")", "for", "v", "in", "val", ")", "else", ":", "ok", "=", "False", "if", "not", "ok", ":", "raise", "DistutilsOptionError", "(", "\"'%s' must be a list of strings (got %r)\"", "%", "(", "option", ",", "val", ")", ")" ]

[ "Helper", "for", "_AddMessageMethods", "()", "." ]

[ "def", "_AddReprMethod", "(", "message_descriptor", ",", "cls", ")", ":", "def", "__repr__", "(", "self", ")", ":", "return", "text_format", ".", "MessageToString", "(", "self", ")", "cls", ".", "__repr__", "=", "__repr__" ]

[ "Provides", "debug", "information", "in", "a", "string", "." ]

[ "def", "_dump", "(", "self", ")", ":", "output", "=", "'MockHttpClient\\n real_client: %s\\n cache file name: %s\\n'", "%", "(", "self", ".", "real_client", ",", "self", ".", "get_cache_file_name", "(", ")", ")", "output", "+=", "' recordings:\\n'", "i", "=", "0", "for", "recording", "in", "self", ".", "_recordings", ":", "output", "+=", "' recording %i is for: %s %s\\n'", "%", "(", "i", ",", "recording", "[", "0", "]", ".", "method", ",", "str", "(", "recording", "[", "0", "]", ".", "uri", ")", ")", "i", "+=", "1", "return", "output" ]

[ "Return", "an", "upper", "bound", "on", "ratio", "()", "relatively", "quickly", "." ]

[ "def", "quick_ratio", "(", "self", ")", ":", "# viewing a and b as multisets, set matches to the cardinality", "# of their intersection; this counts the number of matches", "# without regard to order, so is clearly an upper bound", "if", "self", ".", "fullbcount", "is", "None", ":", "self", ".", "fullbcount", "=", "fullbcount", "=", "{", "}", "for", "elt", "in", "self", ".", "b", ":", "fullbcount", "[", "elt", "]", "=", "fullbcount", ".", "get", "(", "elt", ",", "0", ")", "+", "1", "fullbcount", "=", "self", ".", "fullbcount", "# avail[x] is the number of times x appears in 'b' less the", "# number of times we've seen it in 'a' so far ... kinda", "avail", "=", "{", "}", "availhas", ",", "matches", "=", "avail", ".", "__contains__", ",", "0", "for", "elt", "in", "self", ".", "a", ":", "if", "availhas", "(", "elt", ")", ":", "numb", "=", "avail", "[", "elt", "]", "else", ":", "numb", "=", "fullbcount", ".", "get", "(", "elt", ",", "0", ")", "avail", "[", "elt", "]", "=", "numb", "-", "1", "if", "numb", ">", "0", ":", "matches", "=", "matches", "+", "1", "return", "_calculate_ratio", "(", "matches", ",", "len", "(", "self", ".", "a", ")", "+", "len", "(", "self", ".", "b", ")", ")" ]

[ "Enables", "/", "disables", "the", "button", "at", "position", "index", "." ]

[ "def", "EnableButton", "(", "self", ",", "index", ",", "enable", "=", "True", ")", ":", "if", "index", "<", "0", "or", "index", ">=", "len", "(", "self", ".", "_buttons", ")", ":", "return", "False", "self", ".", "_buttons", "[", "index", "]", ".", "Enable", "(", "enable", ")", "self", ".", "Refresh", "(", ")", "return", "True" ]

[ "Display", "information", "about", "the", "current", "selection", "." ]

[ "def", "setText", "(", "self", ",", "text", ")", ":", "# This method will likely be replaced by the enclosing app to", "# do something more interesting, like write to a text control.", "print", "text" ]

[ "Draw", "random", "samples", "from", "SO", "(", "N", ")", "." ]

[ "def", "rvs", "(", "self", ",", "dim", ",", "size", "=", "1", ",", "random_state", "=", "None", ")", ":", "size", "=", "int", "(", "size", ")", "if", "size", ">", "1", ":", "return", "np", ".", "array", "(", "[", "self", ".", "rvs", "(", "dim", ",", "size", "=", "1", ",", "random_state", "=", "random_state", ")", "for", "i", "in", "range", "(", "size", ")", "]", ")", "dim", "=", "self", ".", "_process_parameters", "(", "dim", ")", "random_state", "=", "self", ".", "_get_random_state", "(", "random_state", ")", "H", "=", "np", ".", "eye", "(", "dim", ")", "D", "=", "np", ".", "ones", "(", "(", "dim", ",", ")", ")", "for", "n", "in", "range", "(", "1", ",", "dim", ")", ":", "x", "=", "random_state", ".", "normal", "(", "size", "=", "(", "dim", "-", "n", "+", "1", ",", ")", ")", "D", "[", "n", "-", "1", "]", "=", "np", ".", "sign", "(", "x", "[", "0", "]", ")", "x", "[", "0", "]", "-=", "D", "[", "n", "-", "1", "]", "*", "np", ".", "sqrt", "(", "(", "x", "*", "x", ")", ".", "sum", "(", ")", ")", "# Householder transformation", "Hx", "=", "(", "np", ".", "eye", "(", "dim", "-", "n", "+", "1", ")", "-", "2.", "*", "np", ".", "outer", "(", "x", ",", "x", ")", "/", "(", "x", "*", "x", ")", ".", "sum", "(", ")", ")", "mat", "=", "np", ".", "eye", "(", "dim", ")", "mat", "[", "n", "-", "1", ":", ",", "n", "-", "1", ":", "]", "=", "Hx", "H", "=", "np", ".", "dot", "(", "H", ",", "mat", ")", "# Fix the last sign such that the determinant is 1", "D", "[", "-", "1", "]", "=", "(", "-", "1", ")", "**", "(", "1", "-", "(", "dim", "%", "2", ")", ")", "*", "D", ".", "prod", "(", ")", "# Equivalent to np.dot(np.diag(D), H) but faster, apparently", "H", "=", "(", "D", "*", "H", ".", "T", ")", ".", "T", "return", "H" ]

[ "This", "calls", "write", "()", "for", "each", "element", "in", "the", "sequence", ".", "The", "sequence", "can", "be", "any", "iterable", "object", "producing", "strings", "typically", "a", "list", "of", "strings", ".", "This", "does", "not", "add", "line", "separators", ".", "There", "is", "no", "return", "value", "." ]

[ "def", "writelines", "(", "self", ",", "sequence", ")", ":", "for", "s", "in", "sequence", ":", "self", ".", "write", "(", "s", ")" ]

[ "Pop", "the", "scope", "until", "it", "is", "at", "the", "level", "of", "the", "given", "indent", ".", "@param", "indent", ":", "indent", "level", "to", "pop", "scope", "to", "@return", ":", "scope", "of", "given", "indent", "level" ]

[ "def", "pop", "(", "self", ",", "indent", ")", ":", "outer", "=", "self", "while", "outer", ".", "parent", "!=", "None", "and", "outer", ".", "indent", ">=", "indent", ":", "outer", "=", "outer", ".", "parent", "return", "outer" ]

[ "Helper", "function", "to", "construct", "a", "multivariate", "level", "/", "trend", "component", "." ]

[ "def", "_replicate_level_trend_models", "(", "multivariate_configuration", ",", "univariate_configuration", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "\"adder\"", ")", ":", "# Construct a level and trend model for each feature, with correlated", "# transition noise.", "adder_features", "=", "[", "]", "for", "feature", "in", "range", "(", "multivariate_configuration", ".", "num_features", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "\"feature{}\"", ".", "format", "(", "feature", ")", ")", ":", "adder_features", ".", "append", "(", "level_trend", ".", "AdderStateSpaceModel", "(", "configuration", "=", "univariate_configuration", ")", ")", "adder_part", "=", "state_space_model", ".", "StateSpaceCorrelatedFeaturesEnsemble", "(", "ensemble_members", "=", "adder_features", ",", "configuration", "=", "multivariate_configuration", ")", "return", "adder_part" ]

[ "Override", "uid", "computation", "and", "make", "it", "to", "be", "engine", "path", "and", "3rdParty", "path", "independent" ]

[ "def", "uid", "(", "self", ")", ":", "try", ":", "return", "self", ".", "uid_", "except", "AttributeError", ":", "# this is not a real hot zone, but we want to avoid surprises here", "m", "=", "Utils", ".", "md5", "(", ")", "up", "=", "m", ".", "update", "up", "(", "self", ".", "__class__", ".", "__name__", ".", "encode", "(", ")", ")", "for", "k", "in", "self", ".", "inputs", "+", "self", ".", "outputs", ":", "s", "=", "replace_engine_path_and_tp_root_in_string", "(", "self", ".", "generator", ".", "bld", ",", "k", ".", "abspath", "(", ")", ")", "up", "(", "s", ")", "self", ".", "uid_", "=", "m", ".", "digest", "(", ")", "return", "self", ".", "uid_" ]

[ "Compute", "a", "hash", "over", "the", "configuration", "for", "the", "given", "context", ".", "The", "goal", "is", "for", "the", "hash", "to", "change", "if", "the", "config", "for", "that", "context", "changes", "but", "not", "if", "a", "change", "is", "made", "to", "the", "config", "only", "for", "a", "different", "platform", "than", "that", "expressed", "by", "ctx", ".", "The", "hash", "is", "intended", "to", "be", "used", "to", "help", "invalidate", "a", "future", "cache", "for", "the", "third", "party", "build", "products", ".", "The", "hasher", "argument", "is", "a", "hash", "object", "returned", "from", "hashlib", "." ]

[ "def", "update_hash", "(", "self", ",", "hasher", ",", "ctx", ")", ":", "for", "section", "in", "sorted", "(", "SCHEMA", ".", "keys", "(", ")", ")", ":", "hasher", ".", "update", "(", "section", ".", "encode", "(", "\"utf-8\"", ")", ")", "# Note: at the time of writing, nothing in the implementation", "# relies on keys in any config section being ordered.", "# In theory we could have conflicting flags in different", "# config sections and later flags override earlier flags.", "# For the purposes of computing a hash we're not super", "# concerned about this: manifest changes should be rare", "# enough and we'd rather that this trigger an invalidation", "# than strive for a cache hit at this time.", "pairs", "=", "self", ".", "get_section_as_ordered_pairs", "(", "section", ",", "ctx", ")", "pairs", ".", "sort", "(", "key", "=", "lambda", "pair", ":", "pair", "[", "0", "]", ")", "for", "key", ",", "value", "in", "pairs", ":", "hasher", ".", "update", "(", "key", ".", "encode", "(", "\"utf-8\"", ")", ")", "if", "value", "is", "not", "None", ":", "hasher", ".", "update", "(", "value", ".", "encode", "(", "\"utf-8\"", ")", ")" ]

[ "interpolateDeriv", "(", "RobotModel", "self", "doubleVector", "a", "doubleVector", "b", ")" ]

[ "def", "interpolateDeriv", "(", "self", ",", "a", ",", "b", ")", ":", "return", "_robotsim", ".", "RobotModel_interpolateDeriv", "(", "self", ",", "a", ",", "b", ")" ]

[ "Helper", "function", "to", "get", "ndarray", "lists", "handles", "from", "various", "inputs", "." ]

[ "def", "_get_ndarray_inputs", "(", "arg_key", ",", "args", ",", "arg_names", ",", "allow_missing", ")", ":", "# setup args", "arg_handles", "=", "[", "]", "arg_arrays", "=", "[", "]", "if", "isinstance", "(", "args", ",", "list", ")", ":", "if", "len", "(", "args", ")", "!=", "len", "(", "arg_names", ")", ":", "raise", "ValueError", "(", "'Length of %s do not match number of arguments'", "%", "arg_key", ")", "for", "narr", "in", "args", ":", "if", "not", "isinstance", "(", "narr", ",", "NDArray", ")", ":", "raise", "TypeError", "(", "'Only Accept list of NDArrays or dict of str to NDArray'", ")", "arg_handles", ".", "append", "(", "narr", ".", "handle", ")", "arg_arrays", "=", "args", "elif", "isinstance", "(", "args", ",", "dict", ")", ":", "for", "name", "in", "arg_names", ":", "if", "name", "in", "args", ":", "narr", "=", "args", "[", "name", "]", "if", "not", "isinstance", "(", "narr", ",", "NDArray", ")", ":", "raise", "TypeError", "(", "'Only Accept list of NDArrays or dict of str to NDArray'", ")", "arg_handles", ".", "append", "(", "narr", ".", "handle", ")", "arg_arrays", ".", "append", "(", "narr", ")", "else", ":", "if", "allow_missing", ":", "arg_handles", ".", "append", "(", "None", ")", "arg_arrays", ".", "append", "(", "None", ")", "else", ":", "raise", "ValueError", "(", "'Must specify all the arguments in %s'", "%", "arg_key", ")", "else", ":", "raise", "TypeError", "(", "'Only Accept list of NDArrays or dict of str to NDArray'", ")", "return", "c_array", "(", "NDArrayHandle", ",", "arg_handles", ")", ",", "arg_arrays" ]

[ "Creates", "an", "SMS", "message", "." ]

[ "def", "CreateSms", "(", "self", ",", "MessageType", ",", "*", "TargetNumbers", ")", ":", "return", "ISmsMessage", "(", "chop", "(", "self", ".", "_DoCommand", "(", "'CREATE SMS %s %s'", "%", "(", "MessageType", ",", "', '", ".", "join", "(", "TargetNumbers", ")", ")", ")", ",", "2", ")", "[", "1", "]", ",", "self", ")" ]

[ "Interface", "for", "list_arguments", ".", "Can", "override", "when", "creating", "new", "operators", "." ]

[ "def", "list_arguments", "(", "self", ")", ":", "return", "[", "'data'", "]" ]

[ "r", "Applies", "a", "1D", "adaptive", "max", "pooling", "over", "an", "input", "signal", "composed", "of", "several", "input", "planes", "." ]

[ "def", "adaptive_max_pool1d_with_indices", "(", "input", ":", "Tensor", ",", "output_size", ":", "BroadcastingList1", "[", "int", "]", ",", "return_indices", ":", "bool", "=", "False", ")", "->", "Tuple", "[", "Tensor", ",", "Tensor", "]", ":", "if", "has_torch_function_unary", "(", "input", ")", ":", "return", "handle_torch_function", "(", "adaptive_max_pool1d_with_indices", ",", "(", "input", ",", ")", ",", "input", ",", "output_size", ",", "return_indices", "=", "return_indices", ")", "return", "torch", ".", "adaptive_max_pool1d", "(", "input", ",", "output_size", ")" ]

[ "Create", "a", "Hilbert", "matrix", "of", "order", "n", "." ]

[ "def", "hilbert", "(", "n", ")", ":", "values", "=", "1.0", "/", "(", "1.0", "+", "np", ".", "arange", "(", "2", "*", "n", "-", "1", ")", ")", "h", "=", "hankel", "(", "values", "[", ":", "n", "]", ",", "r", "=", "values", "[", "n", "-", "1", ":", "]", ")", "return", "h" ]

[ "Returns", "the", "gradient", "of", "x", "and", "y", "given", "the", "gradient", "of", "x", "*", "y", "." ]

[ "def", "_BatchMatMul", "(", "op", ",", "grad", ")", ":", "x", "=", "op", ".", "inputs", "[", "0", "]", "y", "=", "op", ".", "inputs", "[", "1", "]", "adj_x", "=", "op", ".", "get_attr", "(", "\"adj_x\"", ")", "adj_y", "=", "op", ".", "get_attr", "(", "\"adj_y\"", ")", "if", "not", "adj_x", ":", "if", "not", "adj_y", ":", "grad_x", "=", "math_ops", ".", "batch_matmul", "(", "grad", ",", "y", ",", "False", ",", "True", ")", "grad_y", "=", "math_ops", ".", "batch_matmul", "(", "x", ",", "grad", ",", "True", ",", "False", ")", "else", ":", "grad_x", "=", "math_ops", ".", "batch_matmul", "(", "grad", ",", "y", ",", "False", ",", "False", ")", "grad_y", "=", "math_ops", ".", "batch_matmul", "(", "grad", ",", "x", ",", "True", ",", "False", ")", "else", ":", "if", "not", "adj_y", ":", "grad_x", "=", "math_ops", ".", "batch_matmul", "(", "y", ",", "grad", ",", "False", ",", "True", ")", "grad_y", "=", "math_ops", ".", "batch_matmul", "(", "x", ",", "grad", ",", "False", ",", "False", ")", "else", ":", "grad_x", "=", "math_ops", ".", "batch_matmul", "(", "y", ",", "grad", ",", "True", ",", "True", ")", "grad_y", "=", "math_ops", ".", "batch_matmul", "(", "grad", ",", "x", ",", "True", ",", "True", ")", "return", "grad_x", ",", "grad_y" ]

[ "Returns", "whether", "a", "line", "should", "be", "considered", "to", "be", "an", "instruction", "." ]

[ "def", "is_asm", "(", "l", ")", ":", "l", "=", "l", ".", "strip", "(", ")", "# Empty lines", "if", "l", "==", "''", ":", "return", "False", "# Comments", "if", "l", ".", "startswith", "(", "'#'", ")", ":", "return", "False", "# Assembly Macros", "if", "l", ".", "startswith", "(", "'.'", ")", ":", "return", "False", "# Label", "if", "l", ".", "endswith", "(", "':'", ")", ":", "return", "False", "return", "True" ]

[ "Determine", "if", "there", "s", "an", "explicit", "rule", "for", "asm", "files", ".", "When", "there", "isn", "t", "we", "need", "to", "generate", "implicit", "rules", "to", "assemble", ".", "asm", "files", "." ]

[ "def", "HasExplicitAsmRules", "(", "self", ",", "spec", ")", ":", "return", "self", ".", "_HasExplicitRuleForExtension", "(", "spec", ",", "'asm'", ")" ]

[ "Returns", "whether", "this", "is", "a", "(", "non", "-", "quantized", "real", ")", "floating", "point", "type", "." ]

[ "def", "is_floating", "(", "self", ")", ":", "return", "self", ".", "is_numpy_compatible", "and", "issubclass", "(", "self", ".", "as_numpy_dtype", ",", "np", ".", "floating", ")" ]

[ "Whether", "the", "fieldpath", "is", "a", "(", "true", ")", "leaf", "in", "protobuf", "." ]

[ "def", "_IsFieldPathPrimitive", "(", "fieldpath", ",", "protobuf", ")", ":", "toks", "=", "path_utils", ".", "SplitAbstract", "(", "path_utils", ".", "AsAbstract", "(", "fieldpath", ")", ")", "fname", ",", "rest", "=", "path_utils", ".", "FirstRest", "(", "toks", ")", "fd", "=", "protobuf", ".", "DESCRIPTOR", ".", "fields_by_name", ".", "get", "(", "fname", ",", "None", ")", "if", "fd", "is", "None", ":", "return", "False", "while", "bool", "(", "rest", ")", "and", "fd", ".", "type", "==", "fd", ".", "TYPE_MESSAGE", ":", "fname", ",", "rest", "=", "path_utils", ".", "FirstRest", "(", "rest", ")", "fd", "=", "fd", ".", "message_type", ".", "fields_by_name", ".", "get", "(", "fname", ",", "None", ")", "if", "fd", "is", "None", ":", "# path contains something not in the protobuf", "return", "False", "# Both ended on a primitive.", "return", "(", "not", "rest", ")", "and", "(", "fd", ".", "type", "!=", "fd", ".", "TYPE_MESSAGE", ")" ]

[ "Lazy", "loading", "of", "connection", "matrix" ]

[ "def", "cxnmatrix", "(", "self", ")", ":", "# Open brain anatomy, clean lines", "f", "=", "open", "(", "filename", ")", "lines", "=", "[", "x", ".", "strip", "(", "'\\n; '", ")", "for", "x", "in", "f", ".", "readlines", "(", ")", "]", "lines", "=", "lines", "[", "1", ":", "]", "f", ".", "close", "(", ")", "assert", "len", "(", "lines", ")", "==", "self", ".", "num_neurons", ",", "\"#lines != num_neurons\"", "# import all neurons and build the connection matrix with sanity checks", "cells", "=", "[", "float", "(", "cell", ")", "for", "row", "in", "lines", "for", "cell", "in", "row", ".", "split", "(", "' '", ")", "]", "assert", "len", "(", "cells", ")", "==", "self", ".", "num_neurons", "*", "self", ".", "num_neurons", ",", "\"Did not find a square matrix in anatomy file\"", "cxn", "=", "array", "(", "cells", ")", ".", "reshape", "(", "self", ".", "num_neurons", ",", "self", ".", "num_neurons", ")", "assert", "-", "self", ".", "max_weight", "<=", "self", ".", "cxn", ".", "all", "(", ")", "<=", "self", ".", "max_weight", ",", "\"anatomy matrix wasn't within [-max_weight,max_weight]\"", "return", "cxn" ]

[ "Return", "--", "no", "-", "translator", "flag", "if", "we", "run", "*", "msginit", "(", "1", ")", "*", "in", "non", "-", "interactive", "mode", "." ]

[ "def", "_optional_no_translator_flag", "(", "env", ")", ":", "import", "SCons", ".", "Util", "if", "'POAUTOINIT'", "in", "env", ":", "autoinit", "=", "env", "[", "'POAUTOINIT'", "]", "else", ":", "autoinit", "=", "False", "if", "autoinit", ":", "return", "[", "SCons", ".", "Util", ".", "CLVar", "(", "'--no-translator'", ")", "]", "else", ":", "return", "[", "SCons", ".", "Util", ".", "CLVar", "(", "''", ")", "]" ]

[ "对传入的所有pcollection进行协同分组。" ]

[ "def", "cogroup", "(", "*", "pcollections", ",", "*", "*", "options", ")", ":", "import", "bigflow", ".", "transform_impls", ".", "cogroup", "return", "bigflow", ".", "transform_impls", ".", "cogroup", ".", "cogroup", "(", "*", "pcollections", ",", "*", "*", "options", ")" ]

[ "Returns", "the", "current", "EntityResolver", "." ]

[ "def", "getEntityResolver", "(", "self", ")", ":", "return", "self", ".", "_ent_handler" ]

[ "Return", "the", "current", "size", "of", "the", "write", "buffer", "." ]

[ "def", "get_write_buffer_size", "(", "self", ")", ":", "return", "self", ".", "_ssl_protocol", ".", "_transport", ".", "get_write_buffer_size", "(", ")" ]

[ "Mark", "up", "some", "plain", "text", "given", "a", "context", "of", "symbols", "to", "look", "for", ".", "Each", "context", "dictionary", "maps", "object", "names", "to", "anchor", "names", "." ]

[ "def", "markup", "(", "self", ",", "text", ",", "escape", "=", "None", ",", "funcs", "=", "{", "}", ",", "classes", "=", "{", "}", ",", "methods", "=", "{", "}", ")", ":", "escape", "=", "escape", "or", "self", ".", "escape", "results", "=", "[", "]", "here", "=", "0", "pattern", "=", "re", ".", "compile", "(", "r'\\b((http|ftp)://\\S+[\\w/]|'", "r'RFC[- ]?(\\d+)|'", "r'PEP[- ]?(\\d+)|'", "r'(self\\.)?(\\w+))'", ")", "while", "True", ":", "match", "=", "pattern", ".", "search", "(", "text", ",", "here", ")", "if", "not", "match", ":", "break", "start", ",", "end", "=", "match", ".", "span", "(", ")", "results", ".", "append", "(", "escape", "(", "text", "[", "here", ":", "start", "]", ")", ")", "all", ",", "scheme", ",", "rfc", ",", "pep", ",", "selfdot", ",", "name", "=", "match", ".", "groups", "(", ")", "if", "scheme", ":", "url", "=", "escape", "(", "all", ")", ".", "replace", "(", "'\"'", ",", "'&quot;'", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "url", ")", ")", "elif", "rfc", ":", "url", "=", "'http://www.rfc-editor.org/rfc/rfc%d.txt'", "%", "int", "(", "rfc", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "escape", "(", "all", ")", ")", ")", "elif", "pep", ":", "url", "=", "'http://www.python.org/dev/peps/pep-%04d/'", "%", "int", "(", "pep", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "escape", "(", "all", ")", ")", ")", "elif", "selfdot", ":", "# Create a link for methods like 'self.method(...)'", "# and use <strong> for attributes like 'self.attr'", "if", "text", "[", "end", ":", "end", "+", "1", "]", "==", "'('", ":", "results", ".", "append", "(", "'self.'", "+", "self", ".", "namelink", "(", "name", ",", "methods", ")", ")", "else", ":", "results", ".", "append", "(", "'self.<strong>%s</strong>'", "%", "name", ")", "elif", "text", "[", "end", ":", "end", "+", "1", "]", "==", "'('", ":", "results", ".", "append", "(", "self", ".", "namelink", "(", "name", ",", "methods", ",", "funcs", ",", "classes", ")", ")", "else", ":", "results", ".", "append", "(", "self", ".", "namelink", "(", "name", ",", "classes", ")", ")", "here", "=", "end", "results", ".", "append", "(", "escape", "(", "text", "[", "here", ":", "]", ")", ")", "return", "''", ".", "join", "(", "results", ")" ]

[ "Removes", "a", "page", "without", "deleting", "the", "window", "pointer", "." ]

[ "def", "RemovePage", "(", "self", ",", "page_idx", ")", ":", "# save active window pointer", "active_wnd", "=", "None", "if", "self", ".", "_curpage", ">=", "0", ":", "active_wnd", "=", "self", ".", "_tabs", ".", "GetWindowFromIdx", "(", "self", ".", "_curpage", ")", "# save pointer of window being deleted", "wnd", "=", "self", ".", "_tabs", ".", "GetWindowFromIdx", "(", "page_idx", ")", "new_active", "=", "None", "# make sure we found the page", "if", "not", "wnd", ":", "return", "False", "# find out which onscreen tab ctrl owns this tab", "ctrl", ",", "ctrl_idx", "=", "self", ".", "FindTab", "(", "wnd", ")", "if", "not", "ctrl", ":", "return", "False", "currentPage", "=", "ctrl", ".", "GetPage", "(", "ctrl_idx", ")", "is_curpage", "=", "(", "self", ".", "_curpage", "==", "page_idx", ")", "is_active_in_split", "=", "currentPage", ".", "active", "# remove the tab from main catalog", "if", "not", "self", ".", "_tabs", ".", "RemovePage", "(", "wnd", ")", ":", "return", "False", "# remove the tab from the onscreen tab ctrl", "ctrl", ".", "RemovePage", "(", "wnd", ")", "if", "is_active_in_split", ":", "ctrl_new_page_count", "=", "ctrl", ".", "GetPageCount", "(", ")", "if", "ctrl_idx", ">=", "ctrl_new_page_count", ":", "ctrl_idx", "=", "ctrl_new_page_count", "-", "1", "if", "ctrl_idx", ">=", "0", "and", "ctrl_idx", "<", "ctrl", ".", "GetPageCount", "(", ")", ":", "ctrl_idx", "=", "self", ".", "FindNextActiveTab", "(", "ctrl_idx", ",", "ctrl", ")", "# set new page as active in the tab split", "ctrl", ".", "SetActivePage", "(", "ctrl_idx", ")", "# if the page deleted was the current page for the", "# entire tab control, then record the window", "# pointer of the new active page for activation", "if", "is_curpage", ":", "new_active", "=", "ctrl", ".", "GetWindowFromIdx", "(", "ctrl_idx", ")", "else", ":", "# we are not deleting the active page, so keep it the same", "new_active", "=", "active_wnd", "if", "not", "new_active", ":", "# we haven't yet found a new page to active,", "# so select the next page from the main tab", "# catalogue", "if", "0", "<=", "page_idx", "<", "self", ".", "_tabs", ".", "GetPageCount", "(", ")", ":", "new_active", "=", "self", ".", "_tabs", ".", "GetPage", "(", "page_idx", ")", ".", "window", "if", "not", "new_active", "and", "self", ".", "_tabs", ".", "GetPageCount", "(", ")", ">", "0", ":", "new_active", "=", "self", ".", "_tabs", ".", "GetPage", "(", "0", ")", ".", "window", "self", ".", "RemoveEmptyTabFrames", "(", ")", "# set new active pane", "if", "new_active", ":", "if", "not", "self", ".", "IsBeingDeleted", "(", ")", ":", "self", ".", "_curpage", "=", "-", "1", "self", ".", "SetSelectionToWindow", "(", "new_active", ")", "else", ":", "self", ".", "_curpage", "=", "-", "1", "self", ".", "_tabs", ".", "SetNoneActive", "(", ")", "return", "True" ]

[ "__init__", "(", "self", "String", "name", "=", "EmptyString", "String", "value", "=", "EmptyString", "XmlProperty", "next", "=", "None", ")", "-", ">", "XmlProperty" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_xrc", ".", "XmlProperty_swiginit", "(", "self", ",", "_xrc", ".", "new_XmlProperty", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Rounds", "to", "an", "integer", "." ]

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

[ "Minimal", "Residuum", "method" ]

[ "def", "MinRes", "(", "mat", ",", "rhs", ",", "pre", "=", "None", ",", "sol", "=", "None", ",", "maxsteps", "=", "100", ",", "printrates", "=", "True", ",", "initialize", "=", "True", ",", "tol", "=", "1e-7", ")", ":", "return", "MinResSolver", "(", "mat", "=", "mat", ",", "pre", "=", "pre", ",", "maxiter", "=", "maxsteps", ",", "printrates", "=", "printrates", ",", "tol", "=", "tol", ")", ".", "Solve", "(", "rhs", "=", "rhs", ",", "sol", "=", "sol", ",", "initialize", "=", "initialize", ")" ]

[ "TensorRT", "reduce", "layer", "relies", "on", "the", "binary", "representation", "of", "axes", "to", "determine", "which", "dims", "to", "reduce", ".", "For", "example", "if", "we", "want", "to", "reduce", "on", "dim", "1", "and", "2", "then", "axes", "should", "be", "6", "(", "110", ")", "." ]

[ "def", "get_axes_for_reduce_op", "(", "dim", ":", "Union", "[", "int", ",", "Sequence", "[", "int", "]", "]", ",", "has_implicit_batch_dimension", ":", "bool", ",", ")", "->", "int", ":", "if", "isinstance", "(", "dim", ",", "int", ")", ":", "dim", "=", "(", "dim", ",", ")", "if", "has_implicit_batch_dimension", ":", "assert", "0", "not", "in", "dim", ",", "\"Can't reduce over batch dimension when it's implicit.\"", "axes", "=", "0", "for", "d", "in", "dim", ":", "axes", "|=", "1", "<<", "(", "d", "-", "(", "1", "if", "has_implicit_batch_dimension", "else", "0", ")", ")", "return", "axes" ]

[ "Recursively", "walk", "a", "sequence", "stringifying", "each", "element", "." ]

[ "def", "strseq", "(", "object", ",", "convert", ",", "join", "=", "joinseq", ")", ":", "if", "type", "(", "object", ")", "in", "[", "list", ",", "tuple", "]", ":", "return", "join", "(", "[", "strseq", "(", "_o", ",", "convert", ",", "join", ")", "for", "_o", "in", "object", "]", ")", "else", ":", "return", "convert", "(", "object", ")" ]

[ "Creates", "a", "FailedPreconditionError", "." ]

[ "def", "__init__", "(", "self", ",", "node_def", ",", "op", ",", "message", ")", ":", "super", "(", "FailedPreconditionError", ",", "self", ")", ".", "__init__", "(", "node_def", ",", "op", ",", "message", ",", "FAILED_PRECONDITION", ")" ]

[ "InsertHandler", "(", "self", "XmlResourceHandler", "handler", ")" ]

[ "def", "InsertHandler", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_xrc", ".", "XmlResource_InsertHandler", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "LineScroll", "(", "self", "int", "columns", "int", "lines", ")" ]

[ "def", "LineScroll", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_LineScroll", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Set", "communication", "parameters", "on", "opened", "port", ".", "for", "the", "loop", ":", "//", "protocol", "all", "settings", "are", "ignored!" ]

[ "def", "_reconfigurePort", "(", "self", ")", ":", "# not that's it of any real use, but it helps in the unit tests", "if", "not", "isinstance", "(", "self", ".", "_baudrate", ",", "(", "int", ",", "long", ")", ")", "or", "not", "0", "<", "self", ".", "_baudrate", "<", "2", "**", "32", ":", "raise", "ValueError", "(", "\"invalid baudrate: %r\"", "%", "(", "self", ".", "_baudrate", ")", ")", "if", "self", ".", "logger", ":", "self", ".", "logger", ".", "info", "(", "'_reconfigurePort()'", ")" ]

[ "Gets", "called", "prior", "to", "a", "ufunc", "." ]

[ "def", "__array_prepare__", "(", "self", ",", "result", ",", "context", "=", "None", ")", ":", "# nice error message for non-ufunc types", "if", "(", "context", "is", "not", "None", "and", "(", "not", "isinstance", "(", "self", ".", "_values", ",", "(", "np", ".", "ndarray", ",", "ExtensionArray", ")", ")", "or", "isinstance", "(", "self", ".", "_values", ",", "Categorical", ")", ")", ")", ":", "obj", "=", "context", "[", "1", "]", "[", "0", "]", "raise", "TypeError", "(", "\"{obj} with dtype {dtype} cannot perform \"", "\"the numpy op {op}\"", ".", "format", "(", "obj", "=", "type", "(", "obj", ")", ".", "__name__", ",", "dtype", "=", "getattr", "(", "obj", ",", "'dtype'", ",", "None", ")", ",", "op", "=", "context", "[", "0", "]", ".", "__name__", ")", ")", "return", "result" ]

[ "Load", "a", "template", "from", "the", "loader", ".", "If", "a", "loader", "is", "configured", "this", "method", "asks", "the", "loader", "for", "the", "template", "and", "returns", "a", ":", "class", ":", "Template", ".", "If", "the", "parent", "parameter", "is", "not", "None", ":", "meth", ":", "join_path", "is", "called", "to", "get", "the", "real", "template", "name", "before", "loading", "." ]

[ "def", "get_template", "(", "self", ",", "name", ",", "parent", "=", "None", ",", "globals", "=", "None", ")", ":", "if", "isinstance", "(", "name", ",", "Template", ")", ":", "return", "name", "if", "parent", "is", "not", "None", ":", "name", "=", "self", ".", "join_path", "(", "name", ",", "parent", ")", "return", "self", ".", "_load_template", "(", "name", ",", "self", ".", "make_globals", "(", "globals", ")", ")" ]

[ "r" ]

[ "def", "getMass", "(", "self", ")", "->", "float", ":", "return", "_robotsim", ".", "Mass_getMass", "(", "self", ")" ]

[ "Save", "meta", "data", "to", "json", "file", "." ]

[ "def", "_save_metadata", "(", "self", ",", "step_per_epoch", ",", "unit", ",", "num_samples", ",", "landscape_size", ",", "create_landscape", ")", ":", "data", "=", "{", "\"epoch_group\"", ":", "self", ".", "_epoch_group", ",", "\"model_params_file_map\"", ":", "self", ".", "_model_params_file_map", ",", "\"step_per_epoch\"", ":", "step_per_epoch", ",", "\"unit\"", ":", "unit", ",", "\"num_samples\"", ":", "num_samples", ",", "\"landscape_size\"", ":", "landscape_size", ",", "\"create_landscape\"", ":", "create_landscape", "}", "meta_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_ckpt_dir", ",", "'train_metadata.json'", ")", "try", ":", "with", "open", "(", "meta_path", ",", "'w'", ")", "as", "file", ":", "json", ".", "dump", "(", "data", ",", "file", ")", "os", ".", "chmod", "(", "meta_path", ",", "stat", ".", "S_IRUSR", ")", "except", "OSError", "as", "e", ":", "logger", ".", "error", "(", "\"Write meta data %s failed, detail: %s\"", "%", "(", "meta_path", ",", "str", "(", "e", ")", ")", ")" ]

[ "IsVisible", "(", "self", "TreeItemId", "item", ")", "-", ">", "bool" ]

[ "def", "IsVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "TreeCtrl_IsVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Initialize", "MaxPool3D", "." ]

[ "def", "__init__", "(", "self", ",", "kernel_size", "=", "1", ",", "strides", "=", "1", ",", "pad_mode", "=", "\"VALID\"", ",", "pad_list", "=", "0", ",", "ceil_mode", "=", "None", ",", "data_format", "=", "\"NCDHW\"", ")", ":", "self", ".", "init_prim_io_names", "(", "inputs", "=", "[", "'x'", "]", ",", "outputs", "=", "[", "'output'", "]", ")", "validator", ".", "check_value_type", "(", "'kernel_size'", ",", "kernel_size", ",", "[", "int", ",", "tuple", "]", ",", "self", ".", "name", ")", "validator", ".", "check_value_type", "(", "'strides'", ",", "strides", ",", "[", "int", ",", "tuple", "]", ",", "self", ".", "name", ")", "validator", ".", "check_value_type", "(", "'pad_mode'", ",", "pad_mode", ",", "[", "str", "]", ",", "self", ".", "name", ")", "self", ".", "pad_mode", "=", "validator", ".", "check_string", "(", "pad_mode", ".", "upper", "(", ")", ",", "[", "'VALID'", ",", "'SAME'", ",", "'PAD'", "]", ",", "'pad_mode'", ",", "self", ".", "name", ")", "if", "pad_mode", ".", "upper", "(", ")", "==", "\"PAD\"", ":", "self", ".", "pad_mode", "=", "\"CALCULATED\"", "self", ".", "add_prim_attr", "(", "\"pad_mode\"", ",", "self", ".", "pad_mode", ")", "self", ".", "data_format", "=", "validator", ".", "check_string", "(", "data_format", ",", "[", "'NCDHW'", "]", ",", "'data_format'", ",", "self", ".", "name", ")", "self", ".", "kernel_size", "=", "_check_3d_int_or_tuple", "(", "\"kernel_size\"", ",", "kernel_size", ",", "self", ".", "name", ",", "allow_five", "=", "False", ",", "ret_five", "=", "True", ")", "self", ".", "add_prim_attr", "(", "\"kernel_size\"", ",", "self", ".", "kernel_size", ")", "self", ".", "strides", "=", "_check_3d_int_or_tuple", "(", "\"strides\"", ",", "strides", ",", "self", ".", "name", ",", "allow_five", "=", "False", ",", "ret_five", "=", "True", ")", "self", ".", "add_prim_attr", "(", "\"strides\"", ",", "self", ".", "strides", ")", "if", "ceil_mode", "is", "None", ":", "self", ".", "ceil_mode", "=", "not", "self", ".", "pad_mode", "==", "\"CALCULATED\"", "else", ":", "self", ".", "ceil_mode", "=", "validator", ".", "check_value_type", "(", "'ceil_mode'", ",", "ceil_mode", ",", "[", "bool", "]", ",", "self", ".", "name", ")", "if", "self", ".", "pad_mode", "!=", "\"CALCULATED\"", ":", "raise", "ValueError", "(", "\"When the 'pad_mode' is 'same' or 'valid', the 'ceil_mode' only supports 'None'.\"", ")", "self", ".", "add_prim_attr", "(", "\"ceil_mode\"", ",", "int", "(", "self", ".", "ceil_mode", ")", ")", "validator", ".", "check_value_type", "(", "'pad_list'", ",", "pad_list", ",", "(", "int", ",", "tuple", ")", ",", "self", ".", "name", ")", "self", ".", "pad_list", "=", "pad_list", "if", "isinstance", "(", "self", ".", "pad_list", ",", "int", ")", ":", "self", ".", "pad_list", "=", "(", "self", ".", "pad_list", ",", ")", "*", "6", "if", "len", "(", "self", ".", "pad_list", ")", "==", "3", ":", "self", ".", "pad_list", "=", "(", "pad_list", "[", "0", "]", ",", "pad_list", "[", "0", "]", ",", "pad_list", "[", "1", "]", ",", "pad_list", "[", "1", "]", ",", "pad_list", "[", "2", "]", ",", "pad_list", "[", "2", "]", ")", "if", "len", "(", "self", ".", "pad_list", ")", "!=", "3", "and", "len", "(", "self", ".", "pad_list", ")", "!=", "6", ":", "raise", "ValueError", "(", "f\"For '{self.name}', attr 'pad_list' should be an positive int number or a tuple of \"", "f\"three or six positive int numbers, but got {len(self.pad_list)} numbers.\"", ")", "if", "self", ".", "pad_mode", "!=", "'CALCULATED'", "and", "self", ".", "pad_list", "!=", "(", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ")", ":", "raise", "ValueError", "(", "f\"For '{self.name}', the 'pad_list' must be zero or (0, 0, 0, 0, 0, 0) when 'pad_mode' \"", "f\"is not \\\"pad\\\", but got 'pad_list' is {pad_list} and 'pad_mode' is {pad_mode}.\"", ")", "if", "self", ".", "pad_mode", "==", "'CALCULATED'", ":", "for", "item", "in", "self", ".", "pad_list", ":", "validator", ".", "check_non_negative_int", "(", "item", ",", "'pad_list item'", ",", "self", ".", "name", ")", "self", ".", "add_prim_attr", "(", "\"pad_list\"", ",", "self", ".", "pad_list", ")" ]

[ "Consumes", "a", "string", "value", "." ]

[ "def", "ConsumeString", "(", "self", ")", ":", "bytes", "=", "self", ".", "ConsumeByteString", "(", ")", "try", ":", "return", "unicode", "(", "bytes", ",", "'utf-8'", ")", "except", "UnicodeDecodeError", ",", "e", ":", "raise", "self", ".", "_StringParseError", "(", "e", ")" ]

[ "Args", ":", "message_listener", ":", "A", "MessageListener", "implementation", ".", "The", "ScalarMap", "will", "call", "this", "object", "s", "Modified", "()", "method", "when", "it", "is", "modified", ".", "key_checker", ":", "A", "type_checkers", ".", "ValueChecker", "instance", "to", "run", "on", "keys", "inserted", "into", "this", "container", ".", "value_checker", ":", "A", "type_checkers", ".", "ValueChecker", "instance", "to", "run", "on", "values", "inserted", "into", "this", "container", "." ]

[ "def", "__init__", "(", "self", ",", "message_listener", ",", "message_descriptor", ",", "key_checker", ")", ":", "self", ".", "_message_listener", "=", "message_listener", "self", ".", "_message_descriptor", "=", "message_descriptor", "self", ".", "_key_checker", "=", "key_checker", "self", ".", "_values", "=", "{", "}" ]

[ "Return", "an", "equivalent", "command", "line", "invocation", "of", "the", "process", "." ]

[ "def", "as_command", "(", "self", ")", ":", "default_env", "=", "os", ".", "environ", "env_diff", "=", "self", ".", "env", ".", "copy", "(", ")", "# Remove environment variables that appear in both 'os.environ' and 'self.env'.", "for", "env_var", "in", "default_env", ":", "if", "env_var", "in", "env_diff", "and", "env_diff", "[", "env_var", "]", "==", "default_env", "[", "env_var", "]", ":", "del", "env_diff", "[", "env_var", "]", "sb", "=", "[", "]", "# String builder.", "for", "env_var", "in", "env_diff", ":", "sb", ".", "append", "(", "quote", "(", "\"%s=%s\"", "%", "(", "env_var", ",", "env_diff", "[", "env_var", "]", ")", ")", ")", "sb", ".", "extend", "(", "map", "(", "quote", ",", "self", ".", "args", ")", ")", "return", "\" \"", ".", "join", "(", "sb", ")" ]

[ "SetPropertyValueString", "(", "self", "PGPropArg", "id", "String", "value", ")" ]

[ "def", "SetPropertyValueString", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridInterface_SetPropertyValueString", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Helper", "returning", "the", "smallest", "integer", "exactly", "representable", "by", "dtype", "." ]

[ "def", "_smallest_integer_by_dtype", "(", "dt", ")", ":", "if", "not", "_is_known_dtype", "(", "dt", ")", ":", "raise", "TypeError", "(", "\"Unrecognized dtype: {}\"", ".", "format", "(", "dt", ".", "name", ")", ")", "if", "_is_known_unsigned_by_dtype", "(", "dt", ")", ":", "return", "0", "return", "-", "1", "*", "_largest_integer_by_dtype", "(", "dt", ")" ]

[ "Creates", "an", "IndexedSlices", "to", "pass", "as", "input", "to", "the", "while", "grad", "function", "." ]

[ "def", "_create_grad_indexed_slices_init", "(", "grad_output_slices", ",", "forward_input", ")", ":", "assert", "isinstance", "(", "grad_output_slices", ",", "ops", ".", "IndexedSlices", ")", "assert", "isinstance", "(", "forward_input", ",", "ops", ".", "Tensor", ")", "values_out", "=", "grad_output_slices", ".", "values", "indices_out", "=", "grad_output_slices", ".", "indices", "# Create the initial values tensor.", "if", "values_out", ".", "shape", ".", "is_fully_defined", "(", ")", ":", "values_shape", "=", "tensor_shape", ".", "TensorShape", "(", "[", "0", "]", "+", "values_out", ".", "shape", ".", "as_list", "(", ")", "[", "1", ":", "]", ")", "values", "=", "array_ops", ".", "zeros", "(", "values_shape", ",", "dtype", "=", "values_out", ".", "dtype", ",", "name", "=", "\"values_init\"", ")", "else", ":", "if", "forward_input", ".", "dtype", "==", "dtypes", ".", "resource", ":", "forward_shape", "=", "gen_resource_variable_ops", ".", "variable_shape", "(", "forward_input", ")", "else", ":", "forward_shape", "=", "array_ops", ".", "shape", "(", "forward_input", ")", "values_shape", "=", "array_ops", ".", "concat", "(", "[", "[", "0", "]", ",", "forward_shape", "[", "1", ":", "]", "]", ",", "0", ")", "values", "=", "array_ops", ".", "zeros", "(", "values_shape", ",", "dtype", "=", "values_out", ".", "dtype", ",", "name", "=", "\"values_init\"", ")", "# Create the initial indices tensor.", "indices", "=", "constant_op", ".", "constant", "(", "[", "]", ",", "indices_out", ".", "dtype", ",", "name", "=", "\"indices_init\"", ")", "# Create the initial dense_shape tensor. We assume is the same shape as", "# forward_input, since captured tensors don't change shape across loop", "# iterations.", "if", "forward_input", ".", "dtype", "==", "dtypes", ".", "resource", ":", "shape", "=", "gen_resource_variable_ops", ".", "variable_shape", "(", "forward_input", ",", "name", "=", "\"shape_init\"", ")", "else", ":", "shape", "=", "array_ops", ".", "shape", "(", "forward_input", ",", "name", "=", "\"shape_init\"", ")", "return", "ops", ".", "IndexedSlices", "(", "values", "=", "values", ",", "indices", "=", "indices", ",", "dense_shape", "=", "shape", ")" ]

[ "Return", "true", "if", "there", "are", "i18n", "comments", "or", "function", "calls", "in", "the", "line", "." ]

[ "def", "_LineContainsI18n", "(", "uwline", ")", ":", "if", "style", ".", "Get", "(", "'I18N_COMMENT'", ")", ":", "for", "tok", "in", "uwline", ".", "tokens", ":", "if", "tok", ".", "is_comment", "and", "re", ".", "match", "(", "style", ".", "Get", "(", "'I18N_COMMENT'", ")", ",", "tok", ".", "value", ")", ":", "# Contains an i18n comment.", "return", "True", "if", "style", ".", "Get", "(", "'I18N_FUNCTION_CALL'", ")", ":", "length", "=", "len", "(", "uwline", ".", "tokens", ")", "index", "=", "0", "while", "index", "<", "length", "-", "1", ":", "if", "(", "uwline", ".", "tokens", "[", "index", "+", "1", "]", ".", "value", "==", "'('", "and", "uwline", ".", "tokens", "[", "index", "]", ".", "value", "in", "style", ".", "Get", "(", "'I18N_FUNCTION_CALL'", ")", ")", ":", "return", "True", "index", "+=", "1", "return", "False" ]