Datasets:

sia-precision-education

/

pile_cpp

like 1

[ "replace", "info", "[", "2", "]", "a", "traceback", "instance", "by", "its", "ID" ]

[ "def", "wrap_info", "(", "info", ")", ":", "if", "info", "is", "None", ":", "return", "None", "else", ":", "traceback", "=", "info", "[", "2", "]", "assert", "isinstance", "(", "traceback", ",", "types", ".", "TracebackType", ")", "traceback_id", "=", "id", "(", "traceback", ")", "tracebacktable", "[", "traceback_id", "]", "=", "traceback", "modified_info", "=", "(", "info", "[", "0", "]", ",", "info", "[", "1", "]", ",", "traceback_id", ")", "return", "modified_info" ]

[ "Generate", "the", "(", "recursive", ")", "translation", "for", "a", "class", "or", "namespace", "." ]

[ "def", "_container_get", "(", "self", ",", "container", ",", "level", ",", "h_file", ",", "include_filename", ")", ":", "def", "skippable_attribute", "(", "member", ",", "text", ")", ":", "\"\"\"\n We don't seem to have access to the __attribute__(())s, but at least we can look for stuff we care about.\n\n :param member: The attribute.\n :param text: The raw source corresponding to the region of member.\n \"\"\"", "if", "text", ".", "find", "(", "\"_DEPRECATED\"", ")", "!=", "-", "1", ":", "sip", "[", "\"annotations\"", "]", ".", "add", "(", "\"Deprecated\"", ")", "return", "True", "SipGenerator", ".", "_report_ignoring", "(", "container", ",", "member", ",", "text", ")", "sip", "=", "{", "\"name\"", ":", "container", ".", "displayname", ",", "\"annotations\"", ":", "set", "(", ")", "}", "name", "=", "container", ".", "displayname", "if", "container", ".", "access_specifier", "==", "AccessSpecifier", ".", "PRIVATE", ":", "if", "self", ".", "dump_privates", ":", "logger", ".", "debug", "(", "\"Ignoring private {}\"", ".", "format", "(", "SipGenerator", ".", "describe", "(", "container", ")", ")", ")", "return", "\"\"", "body", "=", "\"\"", "base_specifiers", "=", "[", "]", "template_type_parameters", "=", "[", "]", "had_copy_constructor", "=", "False", "had_const_member", "=", "False", "for", "member", "in", "container", ".", "get_children", "(", ")", ":", "#", "# Only emit items in the translation unit.", "#", "if", "member", ".", "location", ".", "file", ".", "name", "!=", "self", ".", "tu", ".", "spelling", ":", "continue", "decl", "=", "\"\"", "if", "member", ".", "kind", "in", "[", "CursorKind", ".", "CXX_METHOD", ",", "CursorKind", ".", "FUNCTION_DECL", ",", "CursorKind", ".", "FUNCTION_TEMPLATE", ",", "CursorKind", ".", "CONSTRUCTOR", ",", "CursorKind", ".", "DESTRUCTOR", ",", "CursorKind", ".", "CONVERSION_FUNCTION", "]", ":", "decl", "=", "self", ".", "_fn_get", "(", "container", ",", "member", ",", "level", "+", "1", ")", "elif", "member", ".", "kind", "==", "CursorKind", ".", "ENUM_DECL", ":", "decl", "=", "self", ".", "_enum_get", "(", "container", ",", "member", ",", "level", "+", "1", ")", "+", "\";\\n\"", "elif", "member", ".", "kind", "==", "CursorKind", ".", "CXX_ACCESS_SPEC_DECL", ":", "decl", "=", "self", ".", "_get_access_specifier", "(", "member", ",", "level", "+", "1", ")", "elif", "member", ".", "kind", "==", "CursorKind", ".", "TYPEDEF_DECL", ":", "decl", "=", "self", ".", "_typedef_get", "(", "member", ",", "level", "+", "1", ")", "elif", "member", ".", "kind", "==", "CursorKind", ".", "CXX_BASE_SPECIFIER", ":", "#", "# Strip off the leading \"class\". Except for TypeKind.UNEXPOSED...", "#", "base_specifiers", ".", "append", "(", "member", ".", "displayname", ".", "split", "(", "None", ",", "2", ")", "[", "-", "1", "]", ")", "elif", "member", ".", "kind", "==", "CursorKind", ".", "TEMPLATE_TYPE_PARAMETER", ":", "template_type_parameters", ".", "append", "(", "member", ".", "displayname", ")", "elif", "member", ".", "kind", "==", "CursorKind", ".", "TEMPLATE_NON_TYPE_PARAMETER", ":", "template_type_parameters", ".", "append", "(", "member", ".", "type", ".", "spelling", "+", "\" \"", "+", "member", ".", "displayname", ")", "elif", "member", ".", "kind", "in", "[", "CursorKind", ".", "VAR_DECL", ",", "CursorKind", ".", "FIELD_DECL", "]", ":", "had_const_member", "=", "had_const_member", "or", "member", ".", "type", ".", "is_const_qualified", "(", ")", "decl", "=", "self", ".", "_var_get", "(", "container", ",", "member", ",", "level", "+", "1", ")", "elif", "member", ".", "kind", "in", "[", "CursorKind", ".", "NAMESPACE", ",", "CursorKind", ".", "CLASS_DECL", ",", "CursorKind", ".", "CLASS_TEMPLATE", ",", "CursorKind", ".", "CLASS_TEMPLATE_PARTIAL_SPECIALIZATION", ",", "CursorKind", ".", "STRUCT_DECL", ",", "CursorKind", ".", "UNION_DECL", "]", ":", "decl", "=", "self", ".", "_container_get", "(", "member", ",", "level", "+", "1", ",", "h_file", ",", "include_filename", ")", "elif", "member", ".", "kind", "in", "TEMPLATE_KINDS", "+", "[", "CursorKind", ".", "USING_DECLARATION", ",", "CursorKind", ".", "USING_DIRECTIVE", ",", "CursorKind", ".", "CXX_FINAL_ATTR", "]", ":", "#", "# Ignore:", "#", "# TEMPLATE_KINDS: Template type parameter.", "# CursorKind.USING_DECLARATION, CursorKind.USING_DIRECTIVE: Using? Pah!", "# CursorKind.CXX_FINAL_ATTR: Again, not much to be done with this.", "#", "pass", "else", ":", "SipGenerator", ".", "_report_ignoring", "(", "container", ",", "member", ")", "def", "is_copy_constructor", "(", "member", ")", ":", "if", "member", ".", "kind", "!=", "CursorKind", ".", "CONSTRUCTOR", ":", "return", "False", "numParams", "=", "0", "hasSelfType", "=", "False", "for", "child", "in", "member", ".", "get_children", "(", ")", ":", "numParams", "+=", "1", "if", "child", ".", "kind", "==", "CursorKind", ".", "PARM_DECL", ":", "paramType", "=", "child", ".", "type", ".", "spelling", "paramType", "=", "paramType", ".", "split", "(", "\"::\"", ")", "[", "-", "1", "]", "paramType", "=", "paramType", ".", "replace", "(", "\"const\"", ",", "\"\"", ")", ".", "replace", "(", "\"&\"", ",", "\"\"", ")", ".", "strip", "(", ")", "hasSelfType", "=", "paramType", "==", "container", ".", "displayname", "return", "numParams", "==", "1", "and", "hasSelfType", "def", "has_parameter_default", "(", "parameter", ")", ":", "for", "member", "in", "parameter", ".", "get_children", "(", ")", ":", "if", "member", ".", "kind", ".", "is_expression", "(", ")", ":", "return", "True", "return", "False", "def", "is_default_constructor", "(", "member", ")", ":", "if", "member", ".", "kind", "!=", "CursorKind", ".", "CONSTRUCTOR", ":", "return", "False", "numParams", "=", "0", "for", "parameter", "in", "member", ".", "get_children", "(", ")", ":", "if", "(", "has_parameter_default", "(", "parameter", ")", ")", ":", "break", "numParams", "+=", "1", "return", "numParams", "==", "0", "had_copy_constructor", "=", "had_copy_constructor", "or", "is_copy_constructor", "(", "member", ")", "#", "# Discard almost anything which is private.", "#", "if", "member", ".", "access_specifier", "==", "AccessSpecifier", ".", "PRIVATE", ":", "if", "member", ".", "kind", "==", "CursorKind", ".", "CXX_ACCESS_SPEC_DECL", ":", "#", "# We need these because...", "#", "pass", "elif", "is_copy_constructor", "(", "member", ")", "or", "is_default_constructor", "(", "member", ")", ":", "#", "# ...we need to pass private copy contructors to the SIP compiler.", "#", "pass", "else", ":", "if", "self", ".", "dump_privates", ":", "logger", ".", "debug", "(", "\"Ignoring private {}\"", ".", "format", "(", "SipGenerator", ".", "describe", "(", "member", ")", ")", ")", "continue", "if", "decl", ":", "if", "self", ".", "verbose", ":", "pad", "=", "\" \"", "*", "(", "(", "level", "+", "1", ")", "*", "4", ")", "body", "+=", "pad", "+", "\"// {}\\n\"", ".", "format", "(", "SipGenerator", ".", "describe", "(", "member", ")", ")", "body", "+=", "decl", "#", "# Empty containers are still useful if they provide namespaces or forward declarations.", "#", "if", "not", "body", "and", "level", ">=", "0", ":", "body", "=", "\"\\n\"", "text", "=", "self", ".", "_read_source", "(", "container", ".", "extent", ")", "if", "not", "text", ".", "endswith", "(", "\"}\"", ")", ":", "#", "# Forward declaration.", "#", "sip", "[", "\"annotations\"", "]", ".", "add", "(", "\"External\"", ")", "if", "body", "and", "level", ">=", "0", ":", "if", "container", ".", "kind", "==", "CursorKind", ".", "NAMESPACE", ":", "container_type", "=", "\"namespace \"", "+", "name", "elif", "container", ".", "kind", "in", "[", "CursorKind", ".", "CLASS_DECL", ",", "CursorKind", ".", "CLASS_TEMPLATE", ",", "CursorKind", ".", "CLASS_TEMPLATE_PARTIAL_SPECIALIZATION", "]", ":", "container_type", "=", "\"class \"", "+", "name", "elif", "container", ".", "kind", "==", "CursorKind", ".", "STRUCT_DECL", ":", "container_type", "=", "\"struct \"", "+", "name", "elif", "container", ".", "kind", "==", "CursorKind", ".", "UNION_DECL", ":", "container_type", "=", "\"union \"", "+", "name", "else", ":", "raise", "AssertionError", "(", "_", "(", "\"Unexpected container {}: {}[{}]\"", ")", ".", "format", "(", "container", ".", "kind", ",", "name", ",", "container", ".", "extent", ".", "start", ".", "line", ")", ")", "#", "# Generate private copy constructor for non-copyable types.", "#", "if", "had_const_member", "and", "not", "had_copy_constructor", ":", "body", "+=", "\" private:\\n {}(const {} &); // Generated\\n\"", ".", "format", "(", "name", ",", "container", ".", "type", ".", "get_canonical", "(", ")", ".", "spelling", ")", "#", "# Flesh out the SIP context for the rules engine.", "#", "sip", "[", "\"template_parameters\"", "]", "=", "\", \"", ".", "join", "(", "template_type_parameters", ")", "sip", "[", "\"decl\"", "]", "=", "container_type", "sip", "[", "\"base_specifiers\"", "]", "=", "\", \"", ".", "join", "(", "base_specifiers", ")", "sip", "[", "\"body\"", "]", "=", "body", "self", ".", "rules", ".", "container_rules", "(", ")", ".", "apply", "(", "container", ",", "sip", ")", "pad", "=", "\" \"", "*", "(", "level", "*", "4", ")", "if", "sip", "[", "\"name\"", "]", ":", "decl", "=", "pad", "+", "sip", "[", "\"decl\"", "]", "if", "\"External\"", "in", "sip", "[", "\"annotations\"", "]", ":", "#", "# SIP /External/ does not seem to work as one might wish. Suppress.", "#", "body", "=", "decl", "+", "\" /External/;\\n\"", "body", "=", "pad", "+", "\"// Discarded {}\\n\"", ".", "format", "(", "SipGenerator", ".", "describe", "(", "container", ")", ")", "else", ":", "if", "sip", "[", "\"base_specifiers\"", "]", ":", "decl", "+=", "\": \"", "+", "sip", "[", "\"base_specifiers\"", "]", "if", "sip", "[", "\"annotations\"", "]", ":", "decl", "+=", "\" /\"", "+", "\",\"", ".", "join", "(", "sip", "[", "\"annotations\"", "]", ")", "+", "\"/\"", "if", "sip", "[", "\"template_parameters\"", "]", ":", "decl", "=", "pad", "+", "\"template <\"", "+", "sip", "[", "\"template_parameters\"", "]", "+", "\">\\n\"", "+", "decl", "decl", "+=", "\"\\n\"", "+", "pad", "+", "\"{\\n\"", "decl", "+=", "\"%TypeHeaderCode\\n#include <{}>\\n%End\\n\"", ".", "format", "(", "include_filename", ")", "body", "=", "decl", "+", "sip", "[", "\"body\"", "]", "+", "pad", "+", "\"};\\n\"", "else", ":", "body", "=", "pad", "+", "\"// Discarded {}\\n\"", ".", "format", "(", "SipGenerator", ".", "describe", "(", "container", ")", ")", "return", "body" ]

[ "__init__", "(", "THash<", "(", "TInt", "TVec<", "(", "TInt", "int", ")", ">", ")", ">", "self", ")", "-", ">", "TIntIntVH", "__init__", "(", "THash<", "(", "TInt", "TVec<", "(", "TInt", "int", ")", ">", ")", ">", "self", "TIntIntVH", "Hash", ")", "-", ">", "TIntIntVH" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ")", ":", "_snap", ".", "TIntIntVH_swiginit", "(", "self", ",", "_snap", ".", "new_TIntIntVH", "(", "*", "args", ")", ")" ]

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

[ "def", "__init__", "(", "self", ",", "*", "args", ")", ":", "super", "(", "RangeDataset", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "_parse_args", "(", "*", "args", ")" ]

[]

[ "def", "has_commit", "(", "cls", ",", "location", ",", "rev", ")", ":", "try", ":", "cls", ".", "run_command", "(", "[", "'rev-parse'", ",", "'-q'", ",", "'--verify'", ",", "\"sha^\"", "+", "rev", "]", ",", "cwd", "=", "location", ",", "log_failed_cmd", "=", "False", ",", ")", "except", "InstallationError", ":", "return", "False", "else", ":", "return", "True" ]

[ "Determines", "the", "width", "of", "the", "line", "in", "column", "positions", "." ]

[ "def", "get_line_width", "(", "line", ")", ":", "if", "isinstance", "(", "line", ",", "unicode", ")", ":", "width", "=", "0", "for", "c", "in", "unicodedata", ".", "normalize", "(", "'NFC'", ",", "line", ")", ":", "if", "unicodedata", ".", "east_asian_width", "(", "c", ")", "in", "(", "'W'", ",", "'F'", ")", ":", "width", "+=", "2", "elif", "not", "unicodedata", ".", "combining", "(", "c", ")", ":", "width", "+=", "1", "return", "width", "return", "len", "(", "line", ")" ]

[ "Removes", "//", "-", "comments", "and", "single", "-", "line", "C", "-", "style", "/", "*", "*", "/", "comments", "." ]

[ "def", "CleanseComments", "(", "line", ")", ":", "commentpos", "=", "line", ".", "find", "(", "'//'", ")", "if", "commentpos", "!=", "-", "1", "and", "not", "IsCppString", "(", "line", "[", ":", "commentpos", "]", ")", ":", "line", "=", "line", "[", ":", "commentpos", "]", ".", "rstrip", "(", ")", "# get rid of /* ... */", "return", "_RE_PATTERN_CLEANSE_LINE_C_COMMENTS", ".", "sub", "(", "''", ",", "line", ")" ]

[ "Handle", "when", "there", "is", "a", "clear", "or", "remove", "workspace", "event", "in", "the", "ADS", "." ]

[ "def", "handle_ads_clear_or_remove_workspace_event", "(", "self", ",", "_", ":", "str", "=", "None", ")", "->", "None", ":", "self", ".", "dead_time_presenter", ".", "handle_ads_clear_or_remove_workspace_event", "(", ")", "self", ".", "handle_runs_loaded", "(", ")" ]

[ "Check", "if", "req_to_install", "should", "be", "skipped", "." ]

[ "def", "_check_skip_installed", "(", "self", ",", "req_to_install", ")", ":", "# type: (InstallRequirement) -> Optional[str]", "if", "self", ".", "ignore_installed", ":", "return", "None", "req_to_install", ".", "check_if_exists", "(", "self", ".", "use_user_site", ")", "if", "not", "req_to_install", ".", "satisfied_by", ":", "return", "None", "if", "self", ".", "force_reinstall", ":", "self", ".", "_set_req_to_reinstall", "(", "req_to_install", ")", "return", "None", "if", "not", "self", ".", "_is_upgrade_allowed", "(", "req_to_install", ")", ":", "if", "self", ".", "upgrade_strategy", "==", "\"only-if-needed\"", ":", "return", "'already satisfied, skipping upgrade'", "return", "'already satisfied'", "# Check for the possibility of an upgrade. For link-based", "# requirements we have to pull the tree down and inspect to assess", "# the version #, so it's handled way down.", "if", "not", "req_to_install", ".", "link", ":", "try", ":", "self", ".", "finder", ".", "find_requirement", "(", "req_to_install", ",", "upgrade", "=", "True", ")", "except", "BestVersionAlreadyInstalled", ":", "# Then the best version is installed.", "return", "'already up-to-date'", "except", "DistributionNotFound", ":", "# No distribution found, so we squash the error. It will", "# be raised later when we re-try later to do the install.", "# Why don't we just raise here?", "pass", "self", ".", "_set_req_to_reinstall", "(", "req_to_install", ")", "return", "None" ]

[ "Args", ":", "message_listener", ":", "A", "MessageListener", "implementation", ".", "The", "RepeatedScalarFieldContainer", "will", "call", "this", "object", "s", "Modified", "()", "method", "when", "it", "is", "modified", "." ]

[ "def", "__init__", "(", "self", ",", "message_listener", ")", ":", "self", ".", "_message_listener", "=", "message_listener", "self", ".", "_values", "=", "[", "]" ]

[ "Returns", "a", "list", "of", "all", "compounds", "and", "their", "members", "which", "match", "details" ]

[ "def", "find_compounds_and_members", "(", "self", ",", "details", ")", ":", "results", "=", "[", "]", "for", "compound", "in", "self", ".", "compound", ":", "members", "=", "compound", ".", "find_members", "(", "details", ")", "if", "members", ":", "results", ".", "append", "(", "[", "compound", ",", "members", "]", ")", "else", ":", "if", "details", ".", "match", "(", "compound", ")", ":", "results", ".", "append", "(", "[", "compound", ",", "[", "]", "]", ")", "return", "results" ]

[ "GetChildAtIndex", "(", "self", "uint32_t", "idx", ")", "-", ">", "SBValue", "GetChildAtIndex", "(", "self", "uint32_t", "idx", "DynamicValueType", "use_dynamic", "bool", "can_create_synthetic", ")", "-", ">", "SBValue" ]

[ "def", "GetChildAtIndex", "(", "self", ",", "*", "args", ")", ":", "return", "_lldb", ".", "SBValue_GetChildAtIndex", "(", "self", ",", "*", "args", ")" ]

[ "MoveAnchoredObjectToParagraph", "(", "self", "RichTextParagraph", "from", "RichTextParagraph", "to", "RichTextObject", "obj", ")" ]

[ "def", "MoveAnchoredObjectToParagraph", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextParagraphLayoutBox_MoveAnchoredObjectToParagraph", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "pprint", "formated", "version", "of", "the", "experiment", "dict", "." ]

[ "def", "__str__", "(", "self", ")", ":", "return", "pprint", ".", "pformat", "(", "self", ".", "build_json_payload", ")" ]

[ "Parse", "the", "sampler", "for", "MindRecord", "." ]

[ "def", "parse_for_minddataset", "(", "self", ")", ":", "start_index", "=", "self", ".", "start_index", "if", "self", ".", "start_index", "is", "not", "None", "else", "0", "num_samples", "=", "self", ".", "num_samples", "if", "self", ".", "num_samples", "is", "not", "None", "else", "0", "c_sampler", "=", "cde", ".", "MindrecordSequentialSampler", "(", "num_samples", ",", "start_index", ")", "c_child_sampler", "=", "self", ".", "parse_child_for_minddataset", "(", ")", "c_sampler", ".", "add_child", "(", "c_child_sampler", ")", "c_sampler", ".", "set_num_samples", "(", "num_samples", ")", "return", "c_sampler" ]

[ "Block", "until", "the", "internal", "flag", "is", "true", "." ]

[ "def", "wait", "(", "self", ",", "timeout", "=", "None", ")", ":", "with", "self", ".", "__cond", ":", "if", "not", "self", ".", "__flag", ":", "self", ".", "__cond", ".", "wait", "(", "timeout", ")", "return", "self", ".", "__flag" ]

[ "Returns", "all", "used", "addresses", "in", "sorted", "order", "." ]

[ "def", "addresses", "(", "self", ")", ":", "aa", "=", "dict_keys", "(", "self", ".", "_buf", ")", "aa", ".", "sort", "(", ")", "return", "aa" ]

[ "Return", "a", "list", "of", "supported", "tags", "for", "each", "version", "specified", "in", "versions", "." ]

[ "def", "get_supported", "(", "versions", "=", "None", ",", "# type: Optional[List[str]]", "noarch", "=", "False", ",", "# type: bool", "platform", "=", "None", ",", "# type: Optional[str]", "impl", "=", "None", ",", "# type: Optional[str]", "abi", "=", "None", "# type: Optional[str]", ")", ":", "# type: (...) -> List[Pep425Tag]", "supported", "=", "[", "]", "# Versions must be given with respect to the preference", "if", "versions", "is", "None", ":", "version_info", "=", "get_impl_version_info", "(", ")", "versions", "=", "get_all_minor_versions_as_strings", "(", "version_info", ")", "impl", "=", "impl", "or", "get_abbr_impl", "(", ")", "abis", "=", "[", "]", "# type: List[str]", "abi", "=", "abi", "or", "get_abi_tag", "(", ")", "if", "abi", ":", "abis", "[", "0", ":", "0", "]", "=", "[", "abi", "]", "abi3s", "=", "set", "(", ")", "for", "suffix", "in", "get_extension_suffixes", "(", ")", ":", "if", "suffix", ".", "startswith", "(", "'.abi'", ")", ":", "abi3s", ".", "add", "(", "suffix", ".", "split", "(", "'.'", ",", "2", ")", "[", "1", "]", ")", "abis", ".", "extend", "(", "sorted", "(", "list", "(", "abi3s", ")", ")", ")", "abis", ".", "append", "(", "'none'", ")", "if", "not", "noarch", ":", "arch", "=", "platform", "or", "get_platform", "(", ")", "arch_prefix", ",", "arch_sep", ",", "arch_suffix", "=", "arch", ".", "partition", "(", "'_'", ")", "if", "arch", ".", "startswith", "(", "'macosx'", ")", ":", "# support macosx-10.6-intel on macosx-10.9-x86_64", "match", "=", "_osx_arch_pat", ".", "match", "(", "arch", ")", "if", "match", ":", "name", ",", "major", ",", "minor", ",", "actual_arch", "=", "match", ".", "groups", "(", ")", "tpl", "=", "'{}_{}_%i_%s'", ".", "format", "(", "name", ",", "major", ")", "arches", "=", "[", "]", "for", "m", "in", "reversed", "(", "range", "(", "int", "(", "minor", ")", "+", "1", ")", ")", ":", "for", "a", "in", "get_darwin_arches", "(", "int", "(", "major", ")", ",", "m", ",", "actual_arch", ")", ":", "arches", ".", "append", "(", "tpl", "%", "(", "m", ",", "a", ")", ")", "else", ":", "# arch pattern didn't match (?!)", "arches", "=", "[", "arch", "]", "elif", "arch_prefix", "==", "'manylinux2010'", ":", "# manylinux1 wheels run on most manylinux2010 systems with the", "# exception of wheels depending on ncurses. PEP 571 states", "# manylinux1 wheels should be considered manylinux2010 wheels:", "# https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels", "arches", "=", "[", "arch", ",", "'manylinux1'", "+", "arch_sep", "+", "arch_suffix", "]", "elif", "platform", "is", "None", ":", "arches", "=", "[", "]", "if", "is_manylinux2010_compatible", "(", ")", ":", "arches", ".", "append", "(", "'manylinux2010'", "+", "arch_sep", "+", "arch_suffix", ")", "if", "is_manylinux1_compatible", "(", ")", ":", "arches", ".", "append", "(", "'manylinux1'", "+", "arch_sep", "+", "arch_suffix", ")", "arches", ".", "append", "(", "arch", ")", "else", ":", "arches", "=", "[", "arch", "]", "# Current version, current API (built specifically for our Python):", "for", "abi", "in", "abis", ":", "for", "arch", "in", "arches", ":", "supported", ".", "append", "(", "(", "'%s%s'", "%", "(", "impl", ",", "versions", "[", "0", "]", ")", ",", "abi", ",", "arch", ")", ")", "# abi3 modules compatible with older version of Python", "for", "version", "in", "versions", "[", "1", ":", "]", ":", "# abi3 was introduced in Python 3.2", "if", "version", "in", "{", "'31'", ",", "'30'", "}", ":", "break", "for", "abi", "in", "abi3s", ":", "# empty set if not Python 3", "for", "arch", "in", "arches", ":", "supported", ".", "append", "(", "(", "\"%s%s\"", "%", "(", "impl", ",", "version", ")", ",", "abi", ",", "arch", ")", ")", "# Has binaries, does not use the Python API:", "for", "arch", "in", "arches", ":", "supported", ".", "append", "(", "(", "'py%s'", "%", "(", "versions", "[", "0", "]", "[", "0", "]", ")", ",", "'none'", ",", "arch", ")", ")", "# No abi / arch, but requires our implementation:", "supported", ".", "append", "(", "(", "'%s%s'", "%", "(", "impl", ",", "versions", "[", "0", "]", ")", ",", "'none'", ",", "'any'", ")", ")", "# Tagged specifically as being cross-version compatible", "# (with just the major version specified)", "supported", ".", "append", "(", "(", "'%s%s'", "%", "(", "impl", ",", "versions", "[", "0", "]", "[", "0", "]", ")", ",", "'none'", ",", "'any'", ")", ")", "# No abi / arch, generic Python", "for", "i", ",", "version", "in", "enumerate", "(", "versions", ")", ":", "supported", ".", "append", "(", "(", "'py%s'", "%", "(", "version", ",", ")", ",", "'none'", ",", "'any'", ")", ")", "if", "i", "==", "0", ":", "supported", ".", "append", "(", "(", "'py%s'", "%", "(", "version", "[", "0", "]", ")", ",", "'none'", ",", "'any'", ")", ")", "return", "supported" ]

[ "GetRangeIndexForBlockAddress", "(", "self", "SBAddress", "block_addr", ")", "-", ">", "uint32_t" ]

[ "def", "GetRangeIndexForBlockAddress", "(", "self", ",", "*", "args", ")", ":", "return", "_lldb", ".", "SBBlock_GetRangeIndexForBlockAddress", "(", "self", ",", "*", "args", ")" ]

[ "makefile", "(", "...", ")", "-", ">", "an", "I", "/", "O", "stream", "connected", "to", "the", "socket" ]

[ "def", "makefile", "(", "self", ",", "mode", "=", "\"r\"", ",", "buffering", "=", "None", ",", "*", ",", "encoding", "=", "None", ",", "errors", "=", "None", ",", "newline", "=", "None", ")", ":", "# XXX refactor to share code?", "if", "not", "set", "(", "mode", ")", "<=", "{", "\"r\"", ",", "\"w\"", ",", "\"b\"", "}", ":", "raise", "ValueError", "(", "\"invalid mode %r (only r, w, b allowed)\"", "%", "(", "mode", ",", ")", ")", "writing", "=", "\"w\"", "in", "mode", "reading", "=", "\"r\"", "in", "mode", "or", "not", "writing", "assert", "reading", "or", "writing", "binary", "=", "\"b\"", "in", "mode", "rawmode", "=", "\"\"", "if", "reading", ":", "rawmode", "+=", "\"r\"", "if", "writing", ":", "rawmode", "+=", "\"w\"", "raw", "=", "SocketIO", "(", "self", ",", "rawmode", ")", "self", ".", "_io_refs", "+=", "1", "if", "buffering", "is", "None", ":", "buffering", "=", "-", "1", "if", "buffering", "<", "0", ":", "buffering", "=", "io", ".", "DEFAULT_BUFFER_SIZE", "if", "buffering", "==", "0", ":", "if", "not", "binary", ":", "raise", "ValueError", "(", "\"unbuffered streams must be binary\"", ")", "return", "raw", "if", "reading", "and", "writing", ":", "buffer", "=", "io", ".", "BufferedRWPair", "(", "raw", ",", "raw", ",", "buffering", ")", "elif", "reading", ":", "buffer", "=", "io", ".", "BufferedReader", "(", "raw", ",", "buffering", ")", "else", ":", "assert", "writing", "buffer", "=", "io", ".", "BufferedWriter", "(", "raw", ",", "buffering", ")", "if", "binary", ":", "return", "buffer", "text", "=", "io", ".", "TextIOWrapper", "(", "buffer", ",", "encoding", ",", "errors", ",", "newline", ")", "text", ".", "mode", "=", "mode", "return", "text" ]

[ "Returns", "fragmented", "molecule", "for", "the", "given", "composition", "element" ]

[ "def", "getFragmentedMolecule", "(", "self", ",", "elem", ",", "options", "=", "\"\"", ")", ":", "if", "options", "is", "None", ":", "options", "=", "\"\"", "self", ".", "_setSessionId", "(", ")", "newobj", "=", "self", ".", "_checkResult", "(", "Indigo", ".", "_lib", ".", "indigoGetFragmentedMolecule", "(", "elem", ".", "id", ",", "options", ".", "encode", "(", "ENCODE_ENCODING", ")", ")", ")", "if", "newobj", "==", "0", ":", "return", "None", "else", ":", "return", "self", ".", "IndigoObject", "(", "self", ",", "newobj", ",", "self", ")" ]

[ "Set", "the", "provided", "convergence", "accelerator", "to", "the", "current", "FSI", "coupling", "interface" ]

[ "def", "SetConvergenceAccelerator", "(", "self", ",", "convergence_accelerator", ")", ":", "self", ".", "convergence_accelerator", "=", "convergence_accelerator" ]

[ "Wrapper", "method", "to", "check", "the", "parameters", "of", "rgb_to_bgr", "." ]

[ "def", "check_rgb_to_bgr", "(", "method", ")", ":", "@", "wraps", "(", "method", ")", "def", "new_method", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "[", "is_hwc", "]", ",", "_", "=", "parse_user_args", "(", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")", "type_check", "(", "is_hwc", ",", "(", "bool", ",", ")", ",", "\"is_hwc\"", ")", "return", "method", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "new_method" ]

[ "Extension", "to", ":", "class", ":", "scanString", "to", "modify", "matching", "text", "with", "modified", "tokens", "that", "may", "be", "returned", "from", "a", "parse", "action", ".", "To", "use", "transformString", "define", "a", "grammar", "and", "attach", "a", "parse", "action", "to", "it", "that", "modifies", "the", "returned", "token", "list", ".", "Invoking", "transformString", "()", "on", "a", "target", "string", "will", "then", "scan", "for", "matches", "and", "replace", "the", "matched", "text", "patterns", "according", "to", "the", "logic", "in", "the", "parse", "action", ".", "transformString", "()", "returns", "the", "resulting", "transformed", "string", "." ]

[ "def", "transformString", "(", "self", ",", "instring", ")", ":", "out", "=", "[", "]", "lastE", "=", "0", "# force preservation of <TAB>s, to minimize unwanted transformation of string, and to", "# keep string locs straight between transformString and scanString", "self", ".", "keepTabs", "=", "True", "try", ":", "for", "t", ",", "s", ",", "e", "in", "self", ".", "scanString", "(", "instring", ")", ":", "out", ".", "append", "(", "instring", "[", "lastE", ":", "s", "]", ")", "if", "t", ":", "if", "isinstance", "(", "t", ",", "ParseResults", ")", ":", "out", "+=", "t", ".", "asList", "(", ")", "elif", "isinstance", "(", "t", ",", "list", ")", ":", "out", "+=", "t", "else", ":", "out", ".", "append", "(", "t", ")", "lastE", "=", "e", "out", ".", "append", "(", "instring", "[", "lastE", ":", "]", ")", "out", "=", "[", "o", "for", "o", "in", "out", "if", "o", "]", "return", "\"\"", ".", "join", "(", "map", "(", "_ustr", ",", "_flatten", "(", "out", ")", ")", ")", "except", "ParseBaseException", "as", "exc", ":", "if", "ParserElement", ".", "verbose_stacktrace", ":", "raise", "else", ":", "# catch and re-raise exception from here, clearing out pyparsing internal stack trace", "if", "getattr", "(", "exc", ",", "'__traceback__'", ",", "None", ")", "is", "not", "None", ":", "exc", ".", "__traceback__", "=", "self", ".", "_trim_traceback", "(", "exc", ".", "__traceback__", ")", "raise", "exc" ]

[ "Performs", "the", "global", "derivation", "for", "D2B", "following", "the", "logic", ":", "1", ".", "SumOverlappingTubes", "with", "2D", "option", "to", "obtain", "the", "reference", "2", ".", "Loop", "over", "tubes", "make", "ratios", "wrt", "reference", "obtain", "constants", "3", ".", "Apply", "the", "constants", "and", "iterate", "over", "if", "requested" ]

[ "def", "_process_global", "(", "self", ")", ":", "data_type", "=", "'Raw'", "if", "self", ".", "getProperty", "(", "'UseCalibratedData'", ")", ".", "value", ":", "data_type", "=", "'Calibrated'", "constants_ws", "=", "self", ".", "_hide", "(", "'constants'", ")", "response_ws", "=", "self", ".", "_hide", "(", "'resp'", ")", "calib_ws", "=", "self", ".", "_hide", "(", "'calib'", ")", "ref_ws", "=", "self", ".", "_hide", "(", "'ref'", ")", "numors", "=", "[", "]", "self", ".", "_progress", "=", "Progress", "(", "self", ",", "start", "=", "0.0", ",", "end", "=", "1.0", ",", "nreports", "=", "self", ".", "_n_scan_files", ")", "for", "index", ",", "numor", "in", "enumerate", "(", "self", ".", "_input_files", ".", "split", "(", "','", ")", ")", ":", "self", ".", "_progress", ".", "report", "(", "'Pre-processing detector scan '", "+", "numor", "[", "-", "10", ":", "-", "4", "]", ")", "ws_name", "=", "'__raw_'", "+", "str", "(", "index", ")", "numors", ".", "append", "(", "ws_name", ")", "LoadILLDiffraction", "(", "Filename", "=", "numor", ",", "OutputWorkspace", "=", "ws_name", ",", "DataType", "=", "data_type", ")", "self", ".", "_validate_scan", "(", "ws_name", ")", "if", "index", "==", "0", ":", "if", "mtd", "[", "ws_name", "]", ".", "getInstrument", "(", ")", ".", "getName", "(", ")", "!=", "'D2B'", ":", "raise", "RuntimeError", "(", "'Global reference method is not supported for the instrument given'", ")", "self", ".", "_configure_global", "(", "ws_name", ")", "if", "self", ".", "_normalise_to", "==", "'Monitor'", ":", "NormaliseToMonitor", "(", "InputWorkspace", "=", "ws_name", ",", "OutputWorkspace", "=", "ws_name", ",", "MonitorID", "=", "0", ")", "ExtractMonitors", "(", "InputWorkspace", "=", "ws_name", ",", "DetectorWorkspace", "=", "ws_name", ")", "ConvertSpectrumAxis", "(", "InputWorkspace", "=", "ws_name", ",", "OrderAxis", "=", "False", ",", "Target", "=", "\"SignedTheta\"", ",", "OutputWorkspace", "=", "ws_name", ")", "if", "self", ".", "_calib_file", ":", "ApplyDetectorScanEffCorr", "(", "InputWorkspace", "=", "ws_name", ",", "DetectorEfficiencyWorkspace", "=", "calib_ws", ",", "OutputWorkspace", "=", "ws_name", ")", "n_scan_steps", "=", "mtd", "[", "ws_name", "]", ".", "getRun", "(", ")", ".", "getLogData", "(", "\"ScanSteps\"", ")", ".", "value", "if", "n_scan_steps", "!=", "self", ".", "_n_scans_per_file", ":", "self", ".", "log", "(", ")", ".", "warning", "(", "\"Run {0} has {1} scan points instead of {2}.\"", ".", "format", "(", "numor", "[", "-", "10", ":", "-", "4", "]", ",", "n_scan_steps", ",", "self", ".", "_n_scans_per_file", ")", ")", "self", ".", "_crop_last_time_index", "(", "ws_name", ",", "n_scan_steps", ")", "if", "self", ".", "_calib_file", ":", "DeleteWorkspace", "(", "calib_ws", ")", "constants", "=", "np", ".", "ones", "(", "[", "self", ".", "_n_pixels_per_tube", ",", "self", ".", "_n_tubes", "]", ")", "x", "=", "np", ".", "arange", "(", "self", ".", "_n_tubes", ")", "e", "=", "np", ".", "zeros", "(", "[", "self", ".", "_n_pixels_per_tube", ",", "self", ".", "_n_tubes", "]", ")", "CreateWorkspace", "(", "DataX", "=", "np", ".", "tile", "(", "x", ",", "self", ".", "_n_pixels_per_tube", ")", ",", "DataY", "=", "constants", ",", "DataE", "=", "e", ",", "NSpec", "=", "self", ".", "_n_pixels_per_tube", ",", "OutputWorkspace", "=", "constants_ws", ")", "calib_current", "=", "self", ".", "_hide", "(", "'current'", ")", "CloneWorkspace", "(", "InputWorkspace", "=", "constants_ws", ",", "OutputWorkspace", "=", "calib_current", ")", "iteration", "=", "0", "chi2_ndof", "=", "np", ".", "inf", "# set a large number to start with", "self", ".", "_pixels_to_trim", "=", "28", "chi2_ndof_threshold", "=", "1.", "inst", "=", "mtd", "[", "numors", "[", "0", "]", "]", ".", "getInstrument", "(", ")", "if", "inst", ".", "hasParameter", "(", "'pixels_to_trim'", ")", ":", "self", ".", "_pixels_to_trim", "=", "inst", ".", "getIntParameter", "(", "'pixels_to_trim'", ")", "[", "0", "]", "if", "inst", ".", "hasParameter", "(", "'chi2_ndof'", ")", ":", "chi2_ndof_threshold", "=", "inst", ".", "getNumberParameter", "(", "'chi2_ndof'", ")", "[", "0", "]", "while", "iteration", "<", "self", ".", "_n_iterations", "or", "(", "self", ".", "_n_iterations", "==", "0", "and", "chi2_ndof", ">", "chi2_ndof_threshold", ")", ":", "self", ".", "_progress", "=", "Progress", "(", "self", ",", "start", "=", "0.0", ",", "end", "=", "1.0", ",", "nreports", "=", "5", ")", "self", ".", "_progress", ".", "report", "(", "'Starting iteration #'", "+", "str", "(", "iteration", ")", ")", "self", ".", "_derive_calibration_global", "(", "numors", ")", "Multiply", "(", "LHSWorkspace", "=", "constants_ws", ",", "RHSWorkspace", "=", "calib_current", ",", "OutputWorkspace", "=", "constants_ws", ")", "chi2_ndof", "=", "self", ".", "_chi_squared", "(", "calib_current", ")", "if", "iteration", "!=", "0", ":", "self", ".", "log", "(", ")", ".", "warning", "(", "'Iteration {0}: Chi2/NdoF={1} (termination criterion: < {2})'", ".", "format", "(", "iteration", ",", "chi2_ndof", ",", "chi2_ndof_threshold", ")", ")", "iteration", "+=", "1", "if", "self", ".", "_out_response", ":", "for", "index", "in", "range", "(", "self", ".", "_n_scan_files", ")", ":", "ws_name", "=", "'__raw_'", "+", "str", "(", "index", ")", "ApplyDetectorScanEffCorr", "(", "InputWorkspace", "=", "ws_name", ",", "DetectorEfficiencyWorkspace", "=", "calib_current", ",", "OutputWorkspace", "=", "ws_name", ")", "SumOverlappingTubes", "(", "InputWorkspaces", "=", "numors", ",", "OutputWorkspace", "=", "response_ws", ",", "MirrorScatteringAngles", "=", "False", ",", "CropNegativeScatteringAngles", "=", "False", ",", "Normalise", "=", "True", ",", "OutputType", "=", "\"2DTubes\"", ")", "DeleteWorkspace", "(", "ref_ws", ")", "DeleteWorkspaces", "(", "numors", ")", "DeleteWorkspace", "(", "calib_current", ")", "mtd", "[", "constants_ws", "]", ".", "getAxis", "(", "0", ")", ".", "setUnit", "(", "'Label'", ")", ".", "setLabel", "(", "'Tube #'", ",", "''", ")", "mtd", "[", "constants_ws", "]", ".", "getAxis", "(", "1", ")", ".", "setUnit", "(", "'Label'", ")", ".", "setLabel", "(", "'Pixel #'", ",", "''", ")", "mtd", "[", "constants_ws", "]", ".", "setYUnitLabel", "(", "'Calibration constant'", ")" ]

[ "SetBulletRightMargin", "(", "int", "margin", ")" ]

[ "def", "SetBulletRightMargin", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextBuffer_SetBulletRightMargin", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "content", "-", "transfer", "-", "encoding", "used", "for", "body", "encoding", "." ]

[ "def", "get_body_encoding", "(", "self", ")", ":", "assert", "self", ".", "body_encoding", "!=", "SHORTEST", "if", "self", ".", "body_encoding", "==", "QP", ":", "return", "'quoted-printable'", "elif", "self", ".", "body_encoding", "==", "BASE64", ":", "return", "'base64'", "else", ":", "return", "encode_7or8bit" ]

[ "Resolve", "all", "streams", "that", "match", "a", "given", "predicate", "." ]

[ "def", "resolve_bypred", "(", "predicate", ",", "minimum", "=", "1", ",", "timeout", "=", "FOREVER", ")", ":", "# noinspection PyCallingNonCallable", "buffer", "=", "(", "c_void_p", "*", "1024", ")", "(", ")", "num_found", "=", "lib", ".", "lsl_resolve_bypred", "(", "byref", "(", "buffer", ")", ",", "1024", ",", "c_char_p", "(", "str", ".", "encode", "(", "predicate", ")", ")", ",", "minimum", ",", "c_double", "(", "timeout", ")", ")", "return", "[", "StreamInfo", "(", "handle", "=", "buffer", "[", "k", "]", ")", "for", "k", "in", "range", "(", "num_found", ")", "]" ]

[ "Adds", "the", "String", "Child", "of", ":", "…", "…", "to", "rst_data", "." ]

[ "def", "add_child_of", "(", "rst_data", ",", "outfile", ")", ":", "found_classes", "=", "RSTDATA_CLS_RE", ".", "findall", "(", "rst_data", ")", "for", "c_name", "in", "found_classes", ":", "cls_inst", "=", "classes", ".", "get_instance", "(", "c_name", ",", "outfile", ")", "parents", "=", "classes", ".", "get_parent_tree", "(", "cls_inst", ")", "if", "parents", ":", "repl_str", "=", "'.. class:: {}\\n\\n'", ".", "format", "(", "cls_inst", ".", "name", ")", "child_str", "=", "'{} Child of:'", ".", "format", "(", "repl_str", ")", "for", "i", ",", "parent", "in", "enumerate", "(", "parents", ")", ":", "if", "classes", ".", "have_same_source", "(", "parent", ",", "cls_inst", ")", ":", "cls_name", "=", "parent", ".", "name", "else", ":", "# Apply the long name to make sphinx-links work across", "# documents", "cls_name", "=", "parent", ".", "long_name", "child_str", "+=", "' :class:`{}`'", ".", "format", "(", "cls_name", ")", "if", "i", "<", "len", "(", "parents", ")", "-", "1", ":", "# Add separator except after last entry", "child_str", "+=", "', '", "child_str", "+=", "'\\n\\n'", "rst_data", "=", "rst_data", ".", "replace", "(", "repl_str", ",", "child_str", ")", "return", "rst_data" ]

[ "Sets", "the", "module", "s", "error", "-", "message", "filters", "." ]

[ "def", "_SetFilters", "(", "filters", ")", ":", "_cpplint_state", ".", "SetFilters", "(", "filters", ")" ]

[ "Gets", "all", "the", "text", "for", "a", "particular", "chunk", ".", "We", "need", "to", "keep", "calling", "get", "text", "till", "all", "the", "segments", "for", "this", "chunk", "are", "retrieved" ]

[ "def", "_get_text", "(", "self", ",", "body_chunks", ")", ":", "while", "True", ":", "try", ":", "body_chunks", ".", "append", "(", "self", ".", "f", ".", "GetText", "(", ")", ")", "except", "pythoncom", ".", "com_error", "as", "e", ":", "if", "e", "[", "0", "]", "in", "[", "FILTER_E_NO_MORE_TEXT", ",", "FILTER_E_NO_MORE_TEXT", ",", "FILTER_E_NO_TEXT", ",", "]", ":", "break", "else", ":", "raise" ]

[ "Creates", "a", "template", "object", "from", "compiled", "code", "and", "the", "globals", ".", "This", "is", "used", "by", "the", "loaders", "and", "environment", "to", "create", "a", "template", "object", "." ]

[ "def", "from_code", "(", "cls", ",", "environment", ",", "code", ",", "globals", ",", "uptodate", "=", "None", ")", ":", "namespace", "=", "{", "'environment'", ":", "environment", ",", "'__file__'", ":", "code", ".", "co_filename", "}", "exec", "(", "code", ",", "namespace", ")", "rv", "=", "cls", ".", "_from_namespace", "(", "environment", ",", "namespace", ",", "globals", ")", "rv", ".", "_uptodate", "=", "uptodate", "return", "rv" ]

[ "the", "number", "of", "total", "columns", "in", "the", "values", "axes" ]

[ "def", "ncols", "(", "self", ")", "->", "int", ":", "return", "sum", "(", "len", "(", "a", ".", "values", ")", "for", "a", "in", "self", ".", "values_axes", ")" ]

[ "Check", "if", "constrains", "are", "satisfied" ]

[ "def", "_check_satisfy_constraints", "(", "self", ",", "label", ",", "xmin", ",", "ymin", ",", "xmax", ",", "ymax", ",", "width", ",", "height", ")", ":", "if", "(", "xmax", "-", "xmin", ")", "*", "(", "ymax", "-", "ymin", ")", "<", "2", ":", "return", "False", "# only 1 pixel", "x1", "=", "float", "(", "xmin", ")", "/", "width", "y1", "=", "float", "(", "ymin", ")", "/", "height", "x2", "=", "float", "(", "xmax", ")", "/", "width", "y2", "=", "float", "(", "ymax", ")", "/", "height", "object_areas", "=", "self", ".", "_calculate_areas", "(", "label", "[", ":", ",", "1", ":", "]", ")", "valid_objects", "=", "np", ".", "where", "(", "object_areas", "*", "width", "*", "height", ">", "2", ")", "[", "0", "]", "if", "valid_objects", ".", "size", "<", "1", ":", "return", "False", "intersects", "=", "self", ".", "_intersect", "(", "label", "[", "valid_objects", ",", "1", ":", "]", ",", "x1", ",", "y1", ",", "x2", ",", "y2", ")", "coverages", "=", "self", ".", "_calculate_areas", "(", "intersects", ")", "/", "object_areas", "[", "valid_objects", "]", "coverages", "=", "coverages", "[", "np", ".", "where", "(", "coverages", ">", "0", ")", "[", "0", "]", "]", "if", "coverages", ".", "size", ">", "0", "and", "np", ".", "amin", "(", "coverages", ")", ">", "self", ".", "min_object_covered", ":", "return", "True" ]

[ "Convert", "to", "lowercase", "count", "word", "occurrences", "and", "save", "top", "-", "k", "words", "to", "a", "file" ]

[ "def", "convert_and_filter_topk", "(", "args", ")", ":", "counter", "=", "Counter", "(", ")", "data_lower", "=", "os", ".", "path", ".", "join", "(", "args", ".", "output_dir", ",", "\"lower.txt.gz\"", ")", "print", "(", "\"\\nConverting to lowercase and counting word occurrences ...\"", ")", "with", "io", ".", "TextIOWrapper", "(", "io", ".", "BufferedWriter", "(", "gzip", ".", "open", "(", "data_lower", ",", "\"w+\"", ")", ")", ",", "encoding", "=", "\"utf-8\"", ")", "as", "file_out", ":", "# Open the input file either from input.txt or input.txt.gz", "_", ",", "file_extension", "=", "os", ".", "path", ".", "splitext", "(", "args", ".", "input_txt", ")", "if", "file_extension", "==", "\".gz\"", ":", "file_in", "=", "io", ".", "TextIOWrapper", "(", "io", ".", "BufferedReader", "(", "gzip", ".", "open", "(", "args", ".", "input_txt", ")", ")", ",", "encoding", "=", "\"utf-8\"", ")", "else", ":", "file_in", "=", "open", "(", "args", ".", "input_txt", ",", "encoding", "=", "\"utf-8\"", ")", "for", "line", "in", "progressbar", ".", "progressbar", "(", "file_in", ")", ":", "line_lower", "=", "line", ".", "lower", "(", ")", "counter", ".", "update", "(", "line_lower", ".", "split", "(", ")", ")", "file_out", ".", "write", "(", "line_lower", ")", "file_in", ".", "close", "(", ")", "# Save top-k words", "print", "(", "\"\\nSaving top {} words ...\"", ".", "format", "(", "args", ".", "top_k", ")", ")", "top_counter", "=", "counter", ".", "most_common", "(", "args", ".", "top_k", ")", "vocab_str", "=", "\"\\n\"", ".", "join", "(", "word", "for", "word", ",", "count", "in", "top_counter", ")", "vocab_path", "=", "\"vocab-{}.txt\"", ".", "format", "(", "args", ".", "top_k", ")", "vocab_path", "=", "os", ".", "path", ".", "join", "(", "args", ".", "output_dir", ",", "vocab_path", ")", "with", "open", "(", "vocab_path", ",", "\"w+\"", ")", "as", "file", ":", "file", ".", "write", "(", "vocab_str", ")", "print", "(", "\"\\nCalculating word statistics ...\"", ")", "total_words", "=", "sum", "(", "counter", ".", "values", "(", ")", ")", "print", "(", "\" Your text file has {} words in total\"", ".", "format", "(", "total_words", ")", ")", "print", "(", "\" It has {} unique words\"", ".", "format", "(", "len", "(", "counter", ")", ")", ")", "top_words_sum", "=", "sum", "(", "count", "for", "word", ",", "count", "in", "top_counter", ")", "word_fraction", "=", "(", "top_words_sum", "/", "total_words", ")", "*", "100", "print", "(", "\" Your top-{} words are {:.4f} percent of all words\"", ".", "format", "(", "args", ".", "top_k", ",", "word_fraction", ")", ")", "print", "(", "' Your most common word \"{}\" occurred {} times'", ".", "format", "(", "*", "top_counter", "[", "0", "]", ")", ")", "last_word", ",", "last_count", "=", "top_counter", "[", "-", "1", "]", "print", "(", "' The least common word in your top-k is \"{}\" with {} times'", ".", "format", "(", "last_word", ",", "last_count", ")", ")", "for", "i", ",", "(", "w", ",", "c", ")", "in", "enumerate", "(", "reversed", "(", "top_counter", ")", ")", ":", "if", "c", ">", "last_count", ":", "print", "(", "' The first word with {} occurrences is \"{}\" at place {}'", ".", "format", "(", "c", ",", "w", ",", "len", "(", "top_counter", ")", "-", "1", "-", "i", ")", ")", "break", "return", "data_lower", ",", "vocab_str" ]

[ "Insert", "(", "self", "String", "item", "int", "pos", "PyObject", "clientData", "=", "None", ")", "-", ">", "int" ]

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

[ "Update", "the", "given", "link", "to", "point", "to", "something", "relative", "to", "the", "new", "path", ":", "param", "link", ":", "The", "link", "to", "change", ":", "param", "in_path", ":", "the", "original", "path", "to", "the", "file", "that", "the", "link", "lives", "in", ":", "return", ":" ]

[ "def", "update_link", "(", "link", ",", "in_path", ",", "out_path", ")", ":", "if", "link", ".", "startswith", "(", "\"http\"", ")", "or", "link", ".", "startswith", "(", "\"javascript:\"", ")", "or", "link", ".", "startswith", "(", "\"#\"", ")", ":", "return", "link", "SEPARATOR", "=", "'/'", "in_path", "=", "in_path", ".", "replace", "(", "'\\\\'", ",", "SEPARATOR", ")", "out_path", "=", "out_path", ".", "replace", "(", "'\\\\'", ",", "SEPARATOR", ")", "link", "=", "link", ".", "replace", "(", "'\\\\'", ",", "SEPARATOR", ")", "base_path", "=", "BASE_PATH", ".", "replace", "(", "'\\\\'", ",", "SEPARATOR", ")", "# if a relative path, make it absolute", "if", "in_path", ".", "find", "(", "base_path", ")", "<", "0", ":", "in_path", "=", "base_path", "+", "in_path", "# get absolute in path", "abs_link_path", "=", "update_link_abs", "(", "link", ",", "in_path", ")", "# convert to relative link in relation to the out path", "src_base", "=", "in_path", ".", "split", "(", "base_path", ")", "[", "1", "]", ".", "split", "(", "SEPARATOR", ")", "[", "0", "]", "# likely htmlsrc", "dest_base", "=", "out_path", ".", "split", "(", "base_path", ")", "[", "1", "]", ".", "split", "(", "SEPARATOR", ")", "[", "0", "]", "# htmlsrc or html", "abs_dest", "=", "posixpath", ".", "dirname", "(", "out_path", ")", ".", "replace", "(", "'\\\\'", ",", "SEPARATOR", ")", "abs_link", "=", "abs_link_path", ".", "replace", "(", "src_base", ",", "dest_base", ")", "# if not posixpath.isabs(abs_link):", "# abs_link = \"/\" + abs_link", "rel_link_path", "=", "relative_url", "(", "abs_dest", ",", "abs_link", ")", "return", "rel_link_path" ]

[ "Replaces", "all", "instances", "of", "Infinity", "/", "-", "Infinity", "/", "NaN", "with", "strings", "." ]

[ "def", "WrapSpecialFloats", "(", "obj", ")", ":", "if", "obj", "==", "float", "(", "'inf'", ")", ":", "return", "'Infinity'", "elif", "obj", "==", "float", "(", "'-inf'", ")", ":", "return", "'-Infinity'", "elif", "isinstance", "(", "obj", ",", "float", ")", "and", "math", ".", "isnan", "(", "obj", ")", ":", "return", "'NaN'", "elif", "isinstance", "(", "obj", ",", "list", ")", "or", "isinstance", "(", "obj", ",", "tuple", ")", ":", "return", "list", "(", "map", "(", "WrapSpecialFloats", ",", "obj", ")", ")", "elif", "isinstance", "(", "obj", ",", "dict", ")", ":", "return", "{", "WrapSpecialFloats", "(", "k", ")", ":", "WrapSpecialFloats", "(", "v", ")", "for", "k", ",", "v", "in", "obj", ".", "items", "(", ")", "}", "else", ":", "return", "obj" ]

[ "A", "helper", "method", "for", "get_cachedir_bsig", "." ]

[ "def", "get_contents_sig", "(", "self", ")", ":", "try", ":", "return", "self", ".", "contentsig", "except", "AttributeError", ":", "pass", "executor", "=", "self", ".", "get_executor", "(", ")", "result", "=", "self", ".", "contentsig", "=", "MD5signature", "(", "executor", ".", "get_contents", "(", ")", ")", "return", "result" ]

[ "Checks", "rules", "from", "the", "C", "++", "language", "rules", "section", "of", "cppguide", ".", "html", "." ]

[ "def", "CheckLanguage", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "file_extension", ",", "include_state", ",", "nesting_state", ",", "error", ")", ":", "# If the line is empty or consists of entirely a comment, no need to", "# check it.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "not", "line", ":", "return", "match", "=", "_RE_PATTERN_INCLUDE", ".", "search", "(", "line", ")", "if", "match", ":", "CheckIncludeLine", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "include_state", ",", "error", ")", "return", "# Reset include state across preprocessor directives. This is meant", "# to silence warnings for conditional includes.", "if", "Match", "(", "r'^\\s*#\\s*(?:ifdef|elif|else|endif)\\b'", ",", "line", ")", ":", "include_state", ".", "ResetSection", "(", ")", "# Make Windows paths like Unix.", "fullname", "=", "os", ".", "path", ".", "abspath", "(", "filename", ")", ".", "replace", "(", "'\\\\'", ",", "'/'", ")", "# TODO(unknown): figure out if they're using default arguments in fn proto.", "# Check to see if they're using an conversion function cast.", "# I just try to capture the most common basic types, though there are more.", "# Parameterless conversion functions, such as bool(), are allowed as they are", "# probably a member operator declaration or default constructor.", "match", "=", "Search", "(", "r'(\\bnew\\s+)?\\b'", "# Grab 'new' operator, if it's there", "r'(int|float|double|bool|char|int32|uint32|int64|uint64)'", "r'(\\([^)].*)'", ",", "line", ")", "if", "match", ":", "matched_new", "=", "match", ".", "group", "(", "1", ")", "matched_type", "=", "match", ".", "group", "(", "2", ")", "matched_funcptr", "=", "match", ".", "group", "(", "3", ")", "# gMock methods are defined using some variant of MOCK_METHODx(name, type)", "# where type may be float(), int(string), etc. Without context they are", "# virtually indistinguishable from int(x) casts. Likewise, gMock's", "# MockCallback takes a template parameter of the form return_type(arg_type),", "# which looks much like the cast we're trying to detect.", "#", "# std::function<> wrapper has a similar problem.", "#", "# Return types for function pointers also look like casts if they", "# don't have an extra space.", "if", "(", "matched_new", "is", "None", "and", "# If new operator, then this isn't a cast", "not", "(", "Match", "(", "r'^\\s*MOCK_(CONST_)?METHOD\\d+(_T)?\\('", ",", "line", ")", "or", "Search", "(", "r'\\bMockCallback<.*>'", ",", "line", ")", "or", "Search", "(", "r'\\bstd::function<.*>'", ",", "line", ")", ")", "and", "not", "(", "matched_funcptr", "and", "Match", "(", "r'\\((?:[^() ]+::\\s*\\*\\s*)?[^() ]+\\)\\s*\\('", ",", "matched_funcptr", ")", ")", ")", ":", "# Try a bit harder to catch gmock lines: the only place where", "# something looks like an old-style cast is where we declare the", "# return type of the mocked method, and the only time when we", "# are missing context is if MOCK_METHOD was split across", "# multiple lines. The missing MOCK_METHOD is usually one or two", "# lines back, so scan back one or two lines.", "#", "# It's not possible for gmock macros to appear in the first 2", "# lines, since the class head + section name takes up 2 lines.", "if", "(", "linenum", "<", "2", "or", "not", "(", "Match", "(", "r'^\\s*MOCK_(?:CONST_)?METHOD\\d+(?:_T)?\\((?:\\S+,)?\\s*$'", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", ")", "or", "Match", "(", "r'^\\s*MOCK_(?:CONST_)?METHOD\\d+(?:_T)?\\(\\s*$'", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "2", "]", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/casting'", ",", "4", ",", "'Using deprecated casting style. '", "'Use static_cast<%s>(...) instead'", "%", "matched_type", ")", "CheckCStyleCast", "(", "filename", ",", "linenum", ",", "line", ",", "clean_lines", ".", "raw_lines", "[", "linenum", "]", ",", "'static_cast'", ",", "r'\\((int|float|double|bool|char|u?int(16|32|64))\\)'", ",", "error", ")", "# This doesn't catch all cases. Consider (const char * const)\"hello\".", "#", "# (char *) \"foo\" should always be a const_cast (reinterpret_cast won't", "# compile).", "if", "CheckCStyleCast", "(", "filename", ",", "linenum", ",", "line", ",", "clean_lines", ".", "raw_lines", "[", "linenum", "]", ",", "'const_cast'", ",", "r'\\((char\\s?\\*+\\s?)\\)\\s*\"'", ",", "error", ")", ":", "pass", "else", ":", "# Check pointer casts for other than string constants", "CheckCStyleCast", "(", "filename", ",", "linenum", ",", "line", ",", "clean_lines", ".", "raw_lines", "[", "linenum", "]", ",", "'reinterpret_cast'", ",", "r'\\((\\w+\\s?\\*+\\s?)\\)'", ",", "error", ")", "# In addition, we look for people taking the address of a cast. This", "# is dangerous -- casts can assign to temporaries, so the pointer doesn't", "# point where you think.", "match", "=", "Search", "(", "r'(?:&\\(([^)]+)\\)[\\w(])|'", "r'(?:&(static|dynamic|down|reinterpret)_cast\\b)'", ",", "line", ")", "if", "match", "and", "match", ".", "group", "(", "1", ")", "!=", "'*'", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/casting'", ",", "4", ",", "(", "'Are you taking an address of a cast? '", "'This is dangerous: could be a temp var. '", "'Take the address before doing the cast, rather than after'", ")", ")", "# Create an extended_line, which is the concatenation of the current and", "# next lines, for more effective checking of code that may span more than one", "# line.", "if", "linenum", "+", "1", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "extended_line", "=", "line", "+", "clean_lines", ".", "elided", "[", "linenum", "+", "1", "]", "else", ":", "extended_line", "=", "line", "# Check for people declaring static/global STL strings at the top level.", "# This is dangerous because the C++ language does not guarantee that", "# globals with constructors are initialized before the first access.", "match", "=", "Match", "(", "r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\\b(.*)'", ",", "line", ")", "# Make sure it's not a function.", "# Function template specialization looks like: \"string foo<Type>(...\".", "# Class template definitions look like: \"string Foo<Type>::Method(...\".", "#", "# Also ignore things that look like operators. These are matched separately", "# because operator names cross non-word boundaries. If we change the pattern", "# above, we would decrease the accuracy of matching identifiers.", "if", "(", "match", "and", "not", "Search", "(", "r'\\boperator\\W'", ",", "line", ")", "and", "not", "Match", "(", "r'\\s*(<.*>)?(::[a-zA-Z0-9_]+)?\\s*\\(([^\"]|$)'", ",", "match", ".", "group", "(", "3", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/string'", ",", "4", ",", "'For a static/global string constant, use a C style string instead: '", "'\"%schar %s[]\".'", "%", "(", "match", ".", "group", "(", "1", ")", ",", "match", ".", "group", "(", "2", ")", ")", ")", "if", "Search", "(", "r'\\b([A-Za-z0-9_]*_)\\(\\1\\)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/init'", ",", "4", ",", "'You seem to be initializing a member variable with itself.'", ")", "if", "file_extension", "==", "'h'", ":", "# TODO(unknown): check that 1-arg constructors are explicit.", "# How to tell it's a constructor?", "# (handled in CheckForNonStandardConstructs for now)", "# TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS", "# (level 1 error)", "pass", "# Check if people are using the verboten C basic types. The only exception", "# we regularly allow is \"unsigned short port\" for port.", "if", "Search", "(", "r'\\bshort port\\b'", ",", "line", ")", ":", "if", "not", "Search", "(", "r'\\bunsigned short port\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/int'", ",", "4", ",", "'Use \"unsigned short\" for ports, not \"short\"'", ")", "else", ":", "match", "=", "Search", "(", "r'\\b(short|long(?! +double)|long long)\\b'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/int'", ",", "4", ",", "'Use int16/int64/etc, rather than the C type %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# When snprintf is used, the second argument shouldn't be a literal.", "match", "=", "Search", "(", "r'snprintf\\s*\\(([^,]*),\\s*([0-9]*)\\s*,'", ",", "line", ")", "if", "match", "and", "match", ".", "group", "(", "2", ")", "!=", "'0'", ":", "# If 2nd arg is zero, snprintf is used to calculate size.", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "3", ",", "'If you can, use sizeof(%s) instead of %s as the 2nd arg '", "'to snprintf.'", "%", "(", "match", ".", "group", "(", "1", ")", ",", "match", ".", "group", "(", "2", ")", ")", ")", "# Check if some verboten C functions are being used.", "if", "Search", "(", "r'\\bsprintf\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "5", ",", "'Never use sprintf. Use snprintf instead.'", ")", "match", "=", "Search", "(", "r'\\b(strcpy|strcat)\\b'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "4", ",", "'Almost always, snprintf is better than %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# Check if some verboten operator overloading is going on", "# TODO(unknown): catch out-of-line unary operator&:", "# class X {};", "# int operator&(const X& x) { return 42; } // unary operator&", "# The trick is it's hard to tell apart from binary operator&:", "# class Y { int operator&(const Y& x) { return 23; } }; // binary operator&", "if", "Search", "(", "r'\\boperator\\s*&\\s*\\(\\s*\\)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/operator'", ",", "4", ",", "'Unary operator& is dangerous. Do not use it.'", ")", "# Check for suspicious usage of \"if\" like", "# } if (a == b) {", "if", "Search", "(", "r'\\}\\s*if\\s*\\('", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/braces'", ",", "4", ",", "'Did you mean \"else if\"? If not, start a new line for \"if\".'", ")", "# Check for potential format string bugs like printf(foo).", "# We constrain the pattern not to pick things like DocidForPrintf(foo).", "# Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())", "# TODO(sugawarayu): Catch the following case. Need to change the calling", "# convention of the whole function to process multiple line to handle it.", "# printf(", "# boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);", "printf_args", "=", "_GetTextInside", "(", "line", ",", "r'(?i)\\b(string)?printf\\s*\\('", ")", "if", "printf_args", ":", "match", "=", "Match", "(", "r'([\\w.\\->()]+)$'", ",", "printf_args", ")", "if", "match", "and", "match", ".", "group", "(", "1", ")", "!=", "'__VA_ARGS__'", ":", "function_name", "=", "re", ".", "search", "(", "r'\\b((?:string)?printf)\\s*\\('", ",", "line", ",", "re", ".", "I", ")", ".", "group", "(", "1", ")", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "4", ",", "'Potential format string bug. Do %s(\"%%s\", %s) instead.'", "%", "(", "function_name", ",", "match", ".", "group", "(", "1", ")", ")", ")", "# Check for potential memset bugs like memset(buf, sizeof(buf), 0).", "match", "=", "Search", "(", "r'memset\\s*\\(([^,]*),\\s*([^,]*),\\s*0\\s*\\)'", ",", "line", ")", "if", "match", "and", "not", "Match", "(", "r\"^''|-?[0-9]+|0x[0-9A-Fa-f]$\"", ",", "match", ".", "group", "(", "2", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/memset'", ",", "4", ",", "'Did you mean \"memset(%s, 0, %s)\"?'", "%", "(", "match", ".", "group", "(", "1", ")", ",", "match", ".", "group", "(", "2", ")", ")", ")", "if", "Search", "(", "r'\\busing namespace\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/namespaces'", ",", "5", ",", "'Do not use namespace using-directives. '", "'Use using-declarations instead.'", ")", "# Detect variable-length arrays.", "match", "=", "Match", "(", "r'\\s*(.+::)?(\\w+) [a-z]\\w*\\[(.+)];'", ",", "line", ")", "if", "(", "match", "and", "match", ".", "group", "(", "2", ")", "!=", "'return'", "and", "match", ".", "group", "(", "2", ")", "!=", "'delete'", "and", "match", ".", "group", "(", "3", ")", ".", "find", "(", "']'", ")", "==", "-", "1", ")", ":", "# Split the size using space and arithmetic operators as delimiters.", "# If any of the resulting tokens are not compile time constants then", "# report the error.", "tokens", "=", "re", ".", "split", "(", "r'\\s|\\+|\\-|\\*|\\/|<<|>>]'", ",", "match", ".", "group", "(", "3", ")", ")", "is_const", "=", "True", "skip_next", "=", "False", "for", "tok", "in", "tokens", ":", "if", "skip_next", ":", "skip_next", "=", "False", "continue", "if", "Search", "(", "r'sizeof\\(.+\\)'", ",", "tok", ")", ":", "continue", "if", "Search", "(", "r'arraysize\\(\\w+\\)'", ",", "tok", ")", ":", "continue", "tok", "=", "tok", ".", "lstrip", "(", "'('", ")", "tok", "=", "tok", ".", "rstrip", "(", "')'", ")", "if", "not", "tok", ":", "continue", "if", "Match", "(", "r'\\d+'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'0[xX][0-9a-fA-F]+'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'k[A-Z0-9]\\w*'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'(.+::)?k[A-Z0-9]\\w*'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'(.+::)?[A-Z][A-Z0-9_]*'", ",", "tok", ")", ":", "continue", "# A catch all for tricky sizeof cases, including 'sizeof expression',", "# 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'", "# requires skipping the next token because we split on ' ' and '*'.", "if", "tok", ".", "startswith", "(", "'sizeof'", ")", ":", "skip_next", "=", "True", "continue", "is_const", "=", "False", "break", "if", "not", "is_const", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/arrays'", ",", "1", ",", "'Do not use variable-length arrays. Use an appropriately named '", "\"('k' followed by CamelCase) compile-time constant for the size.\"", ")", "# If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or", "# DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing", "# in the class declaration.", "match", "=", "Match", "(", "(", "r'\\s*'", "r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))'", "r'\\(.*\\);$'", ")", ",", "line", ")", "if", "match", "and", "linenum", "+", "1", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "next_line", "=", "clean_lines", ".", "elided", "[", "linenum", "+", "1", "]", "# We allow some, but not all, declarations of variables to be present", "# in the statement that defines the class. The [\\w\\*,\\s]* fragment of", "# the regular expression below allows users to declare instances of", "# the class or pointers to instances, but not less common types such", "# as function pointers or arrays. It's a tradeoff between allowing", "# reasonable code and avoiding trying to parse more C++ using regexps.", "if", "not", "Search", "(", "r'^\\s*}[\\w\\*,\\s]*;'", ",", "next_line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/constructors'", ",", "3", ",", "match", ".", "group", "(", "1", ")", "+", "' should be the last thing in the class'", ")", "# Check for use of unnamed namespaces in header files. Registration", "# macros are typically OK, so we allow use of \"namespace {\" on lines", "# that end with backslashes.", "if", "(", "file_extension", "==", "'h'", "and", "Search", "(", "r'\\bnamespace\\s*{'", ",", "line", ")", "and", "line", "[", "-", "1", "]", "!=", "'\\\\'", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/namespaces'", ",", "4", ",", "'Do not use unnamed namespaces in header files. See '", "'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'", "' for more information.'", ")" ]

[ "Return", "the", "IPv4", "6to4", "embedded", "address", "." ]

[ "def", "sixtofour", "(", "self", ")", ":", "if", "(", "self", ".", "_ip", ">>", "112", ")", "!=", "0x2002", ":", "return", "None", "return", "IPv4Address", "(", "(", "self", ".", "_ip", ">>", "80", ")", "&", "0xFFFFFFFF", ")" ]

[ "NS", "-", "aware", "implementation", "." ]

[ "def", "__init__", "(", "self", ",", "attrs", ",", "qnames", ")", ":", "self", ".", "_attrs", "=", "attrs", "self", ".", "_qnames", "=", "qnames" ]

[ "DrawRoundedRectangle", "(", "self", "int", "x", "int", "y", "int", "width", "int", "height", "double", "radius", ")" ]

[ "def", "DrawRoundedRectangle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "PseudoDC_DrawRoundedRectangle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Validate", "file", "contents", "with", "filename", "convention", "." ]

[ "def", "validate_blink_idl_definitions", "(", "idl_filename", ",", "idl_file_basename", ",", "definitions", ")", ":", "targets", "=", "(", "definitions", ".", "interfaces", ".", "values", "(", ")", "+", "definitions", ".", "dictionaries", ".", "values", "(", ")", ")", "number_of_targets", "=", "len", "(", "targets", ")", "if", "number_of_targets", ">", "1", ":", "raise", "Exception", "(", "'Expected exactly 1 definition in file {0}, but found {1}'", ".", "format", "(", "idl_filename", ",", "number_of_targets", ")", ")", "if", "number_of_targets", "==", "0", ":", "if", "not", "(", "definitions", ".", "enumerations", "or", "definitions", ".", "typedefs", ")", ":", "raise", "Exception", "(", "'No definition found in %s'", "%", "idl_filename", ")", "return", "target", "=", "targets", "[", "0", "]", "if", "not", "target", ".", "is_partial", "and", "target", ".", "name", "!=", "idl_file_basename", ":", "raise", "Exception", "(", "'Definition name \"{0}\" disagrees with IDL file basename \"{1}\".'", ".", "format", "(", "target", ".", "name", ",", "idl_file_basename", ")", ")" ]

[ "SetItemTextColour", "(", "self", "long", "item", "Colour", "col", ")" ]

[ "def", "SetItemTextColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ListCtrl_SetItemTextColour", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "reference", "to", "the", "left", "child", "tree", "object", "." ]

[ "def", "get_left", "(", "self", ")", ":", "return", "self", ".", "left" ]

[ "Initializer", ".", "Takes", "optional", "type", "content", "and", "name", "." ]

[ "def", "__init__", "(", "self", ",", "type", "=", "None", ",", "content", "=", "None", ",", "name", "=", "None", ")", ":", "if", "type", "is", "not", "None", ":", "assert", "0", "<=", "type", "<", "256", ",", "type", "if", "content", "is", "not", "None", ":", "assert", "isinstance", "(", "content", ",", "str", ")", ",", "repr", "(", "content", ")", "self", ".", "type", "=", "type", "self", ".", "content", "=", "content", "self", ".", "name", "=", "name" ]

[ "Add", "a", "line", "(", "1", "-", "d", "plot", ")", "at", "right", "axis" ]

[ "def", "add_1d_plot_right", "(", "self", ",", "x", ",", "y", ",", "color", "=", "None", ",", "label", "=", "\"\"", ",", "x_label", "=", "None", ",", "ylabel", "=", "None", ",", "marker", "=", "None", ",", "linestyle", "=", "None", ",", "linewidth", "=", "1", ")", ":", "if", "self", ".", "axes2", "is", "None", ":", "self", ".", "axes2", "=", "self", ".", "axes", ".", "twinx", "(", ")", "# Hold previous data", "self", ".", "axes2", ".", "hold", "(", "True", ")", "# Default", "if", "color", "is", "None", ":", "color", "=", "(", "0", ",", "1", ",", "0", ",", "1", ")", "if", "marker", "is", "None", ":", "marker", "=", "'o'", "if", "linestyle", "is", "None", ":", "linestyle", "=", "'-'", "# Special default", "if", "len", "(", "label", ")", "==", "0", ":", "label", "=", "'right'", "color", "=", "'red'", "# color must be RGBA (4-tuple)", "r", "=", "self", ".", "axes2", ".", "plot", "(", "x", ",", "y", ",", "color", "=", "color", ",", "marker", "=", "marker", ",", "linestyle", "=", "linestyle", ",", "label", "=", "label", ",", "linewidth", "=", "linewidth", ")", "# return: list of matplotlib.lines.Line2D object", "self", ".", "axes2", ".", "set_aspect", "(", "'auto'", ")", "# set x-axis and y-axis label", "if", "x_label", "is", "not", "None", ":", "self", ".", "axes2", ".", "set_xlabel", "(", "x_label", ",", "fontsize", "=", "20", ")", "if", "ylabel", "is", "not", "None", ":", "self", ".", "axes2", ".", "set_ylabel", "(", "ylabel", ",", "fontsize", "=", "20", ")", "# set/update legend", "self", ".", "_setup_legend", "(", ")", "# Register", "line_key", "=", "-", "1", "if", "len", "(", "r", ")", "==", "1", ":", "line_key", "=", "self", ".", "_lineIndex", "self", ".", "_lineDict", "[", "line_key", "]", "=", "r", "[", "0", "]", "self", ".", "_lineIndex", "+=", "1", "else", ":", "print", "(", "\"Impoooooooooooooooosible!\"", ")", "# Flush/commit", "self", ".", "draw", "(", ")", "return", "line_key" ]

[ "Disables", "texturing", "on", "the", "entire", "3D", "scene", "graph", "." ]

[ "def", "textureOff", "(", "self", ")", ":", "self", ".", "render", ".", "setTextureOff", "(", "100", ")", "self", ".", "textureEnabled", "=", "0" ]

[ "AbsoluteScopedName", ":", "SCOPE", "IDENTIFIER", "ScopedNameParts" ]

[ "def", "p_AbsoluteScopedName", "(", "self", ",", "p", ")", ":", "assert", "False", "pass" ]

[ "Writes", "a", "dataset", "to", "the", "table", "." ]

[ "def", "write", "(", "self", ",", "dataset", ",", "column_families", ",", "columns", ",", "timestamp", "=", "None", ")", ":", "if", "timestamp", "is", "None", ":", "timestamp", "=", "-", "1", "# Bigtable server provided timestamp.", "for", "tensor_type", "in", "nest", ".", "flatten", "(", "dataset_ops", ".", "get_legacy_output_types", "(", "dataset", ")", ")", ":", "if", "tensor_type", "!=", "dtypes", ".", "string", ":", "raise", "ValueError", "(", "\"Not all elements of the dataset were `tf.string`\"", ")", "for", "shape", "in", "nest", ".", "flatten", "(", "dataset_ops", ".", "get_legacy_output_shapes", "(", "dataset", ")", ")", ":", "if", "not", "shape", ".", "is_compatible_with", "(", "tensor_shape", ".", "TensorShape", "(", "[", "]", ")", ")", ":", "raise", "ValueError", "(", "\"Not all elements of the dataset were scalars\"", ")", "if", "len", "(", "column_families", ")", "!=", "len", "(", "columns", ")", ":", "raise", "ValueError", "(", "\"len(column_families) != len(columns)\"", ")", "if", "len", "(", "nest", ".", "flatten", "(", "dataset_ops", ".", "get_legacy_output_types", "(", "dataset", ")", ")", ")", "!=", "len", "(", "columns", ")", "+", "1", ":", "raise", "ValueError", "(", "\"A column name must be specified for every component of \"", "\"the dataset elements. (e.g.: len(columns) != \"", "\"len(dataset.output_types))\"", ")", "return", "gen_bigtable_ops", ".", "dataset_to_bigtable", "(", "self", ".", "_resource", ",", "dataset", ".", "_variant_tensor", ",", "# pylint: disable=protected-access", "column_families", ",", "columns", ",", "timestamp", ")" ]

[ "Converts", "a", "XLA", "literal", "to", "a", "Numpy", "array", "." ]

[ "def", "ConvertLiteralToNumpyArray", "(", "literal", ")", ":", "element_type", "=", "literal", ".", "shape", ".", "element_type", "if", "element_type", "==", "xla_data_pb2", ".", "TUPLE", ":", "return", "tuple", "(", "ConvertLiteralToNumpyArray", "(", "subliteral", ")", "for", "subliteral", "in", "literal", ".", "tuple_literals", ")", "type_record", "=", "types", ".", "MAP_XLA_TYPE_TO_RECORD", "[", "element_type", "]", "if", "not", "literal", ".", "shape", ".", "dimensions", ":", "return", "_np", ".", "array", "(", "getattr", "(", "literal", ",", "type_record", ".", "literal_field_name", ")", "[", "0", "]", ",", "type_record", ".", "numpy_dtype", ")", "else", ":", "# Infer the proper Numpy order from the LiteralProto's layout. The repeated", "# field representing the array's content in the Literal is linearized.", "# Reading is done in two steps:", "#", "# 1. Read the array as 1D from the LiteralProto repeated field.", "# 2. Reshape the array to its proper shape, using the right order depending", "# on the LiteralProto's layout.", "layout_order", "=", "literal", ".", "shape", ".", "layout", ".", "minor_to_major", "numpy_shape", "=", "tuple", "(", "literal", ".", "shape", ".", "dimensions", ")", "if", "layout_order", "==", "list", "(", "range", "(", "len", "(", "literal", ".", "shape", ".", "dimensions", ")", ")", ")", ":", "numpy_reshaper", "=", "lambda", "arr", ":", "arr", ".", "reshape", "(", "numpy_shape", ",", "order", "=", "'F'", ")", "elif", "layout_order", "==", "list", "(", "range", "(", "len", "(", "literal", ".", "shape", ".", "dimensions", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ")", ":", "numpy_reshaper", "=", "lambda", "arr", ":", "arr", ".", "reshape", "(", "numpy_shape", ",", "order", "=", "'C'", ")", "else", ":", "raise", "NotImplementedError", "(", "'Unsupported layout: {0}'", ".", "format", "(", "layout_order", ")", ")", "ndarray", "=", "_np", ".", "array", "(", "getattr", "(", "literal", ",", "type_record", ".", "literal_field_name", ")", ",", "copy", "=", "False", ",", "dtype", "=", "type_record", ".", "numpy_dtype", ")", "return", "numpy_reshaper", "(", "ndarray", ")" ]

[ "Constructs", "a", "canonic", "path", "from", "the", "specified", "path", "." ]

[ "def", "canonicPath", "(", "path", ")", ":", "ret", "=", "libxml2mod", ".", "xmlCanonicPath", "(", "path", ")", "return", "ret" ]

[ "Logs", "an", "error", "for", "each", "line", "containing", "bad", "characters", "." ]

[ "def", "CheckForBadCharacters", "(", "filename", ",", "lines", ",", "error", ")", ":", "for", "linenum", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "if", "u'\\ufffd'", "in", "line", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/utf8'", ",", "5", ",", "'Line contains invalid UTF-8 (or Unicode replacement character).'", ")", "if", "'\\0'", "in", "line", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nul'", ",", "5", ",", "'Line contains NUL byte.'", ")" ]

[ "Return", "the", "mean", "value", "of", "the", "Array", "." ]

[ "def", "mean", "(", "self", ",", "skipna", "=", "True", ")", ":", "if", "is_period_dtype", "(", "self", ")", ":", "# See discussion in GH#24757", "raise", "TypeError", "(", "f\"mean is not implemented for {type(self).__name__} since the \"", "\"meaning is ambiguous. An alternative is \"", "\"obj.to_timestamp(how='start').mean()\"", ")", "mask", "=", "self", ".", "isna", "(", ")", "if", "skipna", ":", "values", "=", "self", "[", "~", "mask", "]", "elif", "mask", ".", "any", "(", ")", ":", "return", "NaT", "else", ":", "values", "=", "self", "if", "not", "len", "(", "values", ")", ":", "# short-circuit for empty max / min", "return", "NaT", "result", "=", "nanops", ".", "nanmean", "(", "values", ".", "view", "(", "\"i8\"", ")", ",", "skipna", "=", "skipna", ")", "# Don't have to worry about NA `result`, since no NA went in.", "return", "self", ".", "_box_func", "(", "result", ")" ]

[ "Set", "activation", "variables", "to", "be", "persistable", "so", "can", "obtain", "the", "tensor", "data", "in", "sample_data" ]

[ "def", "_set_activation_persistable", "(", "self", ")", ":", "for", "var", "in", "self", ".", "_program", ".", "list_vars", "(", ")", ":", "if", "var", ".", "name", "in", "self", ".", "_quantized_act_var_name", ":", "var", ".", "persistable", "=", "True" ]

[ "This", "can", "be", "called", "from", "the", "main", "thread", "to", "safely", "stop", "this", "thread", "." ]

[ "def", "stop", "(", "self", ")", ":", "self", ".", "stop_now", "=", "True", "self", ".", "history_manager", ".", "save_flag", ".", "set", "(", ")", "self", ".", "join", "(", ")" ]

[ "Compute", "the", "number", "of", "elements", "in", "this", "table", "." ]

[ "def", "size", "(", "self", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "self", ".", "_table_ref", "]", ",", "name", ",", "\"%s_Size\"", "%", "self", ".", "_name", ")", "as", "name", ":", "# pylint: disable=protected-access", "return", "gen_data_flow_ops", ".", "_lookup_table_size", "(", "self", ".", "_table_ref", ",", "name", "=", "name", ")" ]

[ "Helper", "for", "actualize_sources", ".", "For", "each", "passed", "source", "actualizes", "it", "with", "the", "appropriate", "scanner", ".", "Returns", "the", "actualized", "virtual", "targets", "." ]

[ "def", "actualize_source_type", "(", "self", ",", "sources", ",", "prop_set", ")", ":", "result", "=", "[", "]", "for", "i", "in", "sources", ":", "scanner", "=", "None", "# FIXME: what's this?", "# if isinstance (i, str):", "# i = self.manager_.get_object (i)", "if", "i", ".", "type", "(", ")", ":", "scanner", "=", "b2", ".", "build", ".", "type", ".", "get_scanner", "(", "i", ".", "type", "(", ")", ",", "prop_set", ")", "r", "=", "i", ".", "actualize", "(", "scanner", ")", "result", ".", "append", "(", "r", ")", "return", "result" ]

[ "Does", "some", "more", "common", "initialization", "before", "showing", ":", "class", ":", "ShortcutEditor", "." ]

[ "def", "PreShow", "(", "self", ")", ":", "self", ".", "listShortcut", ".", "MakeImageList", "(", ")", "self", ".", "listShortcut", ".", "RecreateTree", "(", ")", "self", ".", "SetColumnWidths", "(", ")" ]

[ "Use", "RelaxNG", "to", "validate", "the", "document", "as", "it", "is", "processed", ".", "Activation", "is", "only", "possible", "before", "the", "first", "Read", "()", ".", "if" ]

[ "def", "RelaxNGSetSchema", "(", "self", ",", "schema", ")", ":", "if", "schema", "is", "None", ":", "schema__o", "=", "None", "else", ":", "schema__o", "=", "schema", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlTextReaderRelaxNGSetSchema", "(", "self", ".", "_o", ",", "schema__o", ")", "return", "ret" ]

[ "Returns", "true", "if", "the", "current", "token", "has", "an", "object", "literal", "ancestor", "." ]

[ "def", "InObjectLiteralDescendant", "(", "self", ")", ":", "return", "self", ".", "OBJECT_LITERAL", "in", "self", ".", "_block_types" ]

[ "return", "a", "blueprint", "for", "a", "new", "agent" ]

[ "def", "get_agent_info", "(", "self", ",", "agent", ")", ":", "for", "a", "in", "constants", ".", "WALL_RAY_SENSORS", ":", "agent", ".", "add_sensor", "(", "OpenNero", ".", "RaySensor", "(", "math", ".", "cos", "(", "math", ".", "radians", "(", "a", ")", ")", ",", "math", ".", "sin", "(", "math", ".", "radians", "(", "a", ")", ")", ",", "0", ",", "constants", ".", "WALL_SENSOR_RADIUS", ",", "constants", ".", "OBJECT_TYPE_OBSTACLE", ",", "False", ")", ")", "for", "a0", ",", "a1", "in", "constants", ".", "FLAG_RADAR_SENSORS", ":", "agent", ".", "add_sensor", "(", "OpenNero", ".", "RadarSensor", "(", "a0", ",", "a1", ",", "-", "90", ",", "90", ",", "constants", ".", "MAX_VISION_RADIUS", ",", "constants", ".", "OBJECT_TYPE_FLAG", ",", "False", ")", ")", "sense", "=", "constants", ".", "OBJECT_TYPE_TEAM_0", "if", "agent", ".", "team_type", "==", "sense", ":", "sense", "=", "constants", ".", "OBJECT_TYPE_TEAM_1", "for", "a0", ",", "a1", "in", "constants", ".", "ENEMY_RADAR_SENSORS", ":", "agent", ".", "add_sensor", "(", "OpenNero", ".", "RadarSensor", "(", "a0", ",", "a1", ",", "-", "90", ",", "90", ",", "constants", ".", "MAX_VISION_RADIUS", ",", "sense", ",", "False", ")", ")", "for", "a", "in", "constants", ".", "TARGETING_SENSORS", ":", "agent", ".", "add_sensor", "(", "OpenNero", ".", "RaySensor", "(", "math", ".", "cos", "(", "math", ".", "radians", "(", "a", ")", ")", ",", "math", ".", "sin", "(", "math", ".", "radians", "(", "a", ")", ")", ",", "0", ",", "constants", ".", "TARGET_SENSOR_RADIUS", ",", "sense", ",", "False", ")", ")", "abound", "=", "OpenNero", ".", "FeatureVectorInfo", "(", ")", "# actions", "sbound", "=", "OpenNero", ".", "FeatureVectorInfo", "(", ")", "# sensors", "# actions", "abound", ".", "add_continuous", "(", "-", "1", ",", "1", ")", "# forward/backward speed", "abound", ".", "add_continuous", "(", "-", "constants", ".", "MAX_TURNING_RATE", ",", "constants", ".", "MAX_TURNING_RATE", ")", "# left/right turn (in radians)", "abound", ".", "add_continuous", "(", "0", ",", "1", ")", "# fire ", "abound", ".", "add_continuous", "(", "0", ",", "1", ")", "# omit friend sensors ", "# sensor dimensions", "for", "a", "in", "range", "(", "constants", ".", "N_SENSORS", ")", ":", "sbound", ".", "add_continuous", "(", "0", ",", "1", ")", "rbound", "=", "OpenNero", ".", "FeatureVectorInfo", "(", ")", "rbound", ".", "add_continuous", "(", "0", ",", "1", ")", "return", "OpenNero", ".", "AgentInitInfo", "(", "sbound", ",", "abound", ",", "rbound", ")" ]

[ "This", "function", "overrides", "the", "_logger", "class", "warning", ":", "param", "msg", ":", "the", "message", "to", "log", ":", "type", "msg", ":", "str" ]

[ "def", "warning", "(", "self", ",", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "PipeLogger", ".", "_has_warning", "=", "True", "super", "(", "PipeLogger", ",", "self", ")", ".", "warning", "(", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Lazy", "initialization", "of", "self", ".", "map", "." ]

[ "def", "_init_map", "(", "self", ")", ":", "if", "self", ".", "map", ":", "return", "self", ".", "map", "=", "{", "}", "for", "type_name", "in", "self", ".", "type_names", ":", "concrete_type", "=", "gdb", ".", "lookup_type", "(", "type_name", ")", "try", ":", "storage", "=", "gdb", ".", "parse_and_eval", "(", "\"&'mlir::detail::TypeIDExported::get<%s>()::instance'\"", "%", "type_name", ")", "except", "gdb", ".", "error", ":", "# Skip when TypeID instance cannot be found in current context.", "continue", "if", "concrete_type", "and", "storage", ":", "self", ".", "map", "[", "int", "(", "storage", ")", "]", "=", "concrete_type" ]

[ "A", "context", "manager", "which", "sets", "up", "a", "conditional", "basic", "block", "based", "on", "the", "given", "predicate", "(", "a", "i1", "value", ")", ".", "If", "the", "conditional", "block", "is", "not", "explicitly", "terminated", "a", "branch", "will", "be", "added", "to", "the", "next", "block", ".", "If", "*", "likely", "*", "is", "given", "its", "boolean", "value", "indicates", "whether", "the", "predicate", "is", "likely", "to", "be", "true", "or", "not", "and", "metadata", "is", "issued", "for", "LLVM", "s", "optimizers", "to", "account", "for", "that", "." ]

[ "def", "if_then", "(", "self", ",", "pred", ",", "likely", "=", "None", ")", ":", "bb", "=", "self", ".", "basic_block", "bbif", "=", "self", ".", "append_basic_block", "(", "name", "=", "_label_suffix", "(", "bb", ".", "name", ",", "'.if'", ")", ")", "bbend", "=", "self", ".", "append_basic_block", "(", "name", "=", "_label_suffix", "(", "bb", ".", "name", ",", "'.endif'", ")", ")", "br", "=", "self", ".", "cbranch", "(", "pred", ",", "bbif", ",", "bbend", ")", "if", "likely", "is", "not", "None", ":", "br", ".", "set_weights", "(", "[", "99", ",", "1", "]", "if", "likely", "else", "[", "1", ",", "99", "]", ")", "with", "self", ".", "_branch_helper", "(", "bbif", ",", "bbend", ")", ":", "yield", "bbend", "self", ".", "position_at_end", "(", "bbend", ")" ]

[ "Raise", "a", "Hermite", "series", "to", "a", "power", "." ]

[ "def", "hermepow", "(", "c", ",", "pow", ",", "maxpower", "=", "16", ")", ":", "# c is a trimmed copy", "[", "c", "]", "=", "pu", ".", "as_series", "(", "[", "c", "]", ")", "power", "=", "int", "(", "pow", ")", "if", "power", "!=", "pow", "or", "power", "<", "0", ":", "raise", "ValueError", "(", "\"Power must be a non-negative integer.\"", ")", "elif", "maxpower", "is", "not", "None", "and", "power", ">", "maxpower", ":", "raise", "ValueError", "(", "\"Power is too large\"", ")", "elif", "power", "==", "0", ":", "return", "np", ".", "array", "(", "[", "1", "]", ",", "dtype", "=", "c", ".", "dtype", ")", "elif", "power", "==", "1", ":", "return", "c", "else", ":", "# This can be made more efficient by using powers of two", "# in the usual way.", "prd", "=", "c", "for", "i", "in", "range", "(", "2", ",", "power", "+", "1", ")", ":", "prd", "=", "hermemul", "(", "prd", ",", "c", ")", "return", "prd" ]

[ "Returns", "the", "number", "of", "irreps", "." ]

[ "def", "nirrep", "(", "self", ")", ":", "return", "self", ".", "PYnirrep" ]

[ "StringLiteralList", ":", "StringLiteral", "StringLiteralList", "|", "StringLiteral" ]

[ "def", "p_StringLiteralList", "(", "self", ",", "p", ")", ":", "def", "unwrap_string", "(", "ls", ")", ":", "\"\"\"Reach in and grab the string literal's \"NAME\".\"\"\"", "return", "ls", "[", "1", "]", ".", "value", "if", "len", "(", "p", ")", ">", "3", ":", "p", "[", "0", "]", "=", "ListFromConcat", "(", "unwrap_string", "(", "p", "[", "1", "]", ")", ",", "p", "[", "3", "]", ")", "else", ":", "p", "[", "0", "]", "=", "ListFromConcat", "(", "unwrap_string", "(", "p", "[", "1", "]", ")", ")" ]

[ "Get", "the", "URL", "to", "download", "the", "detector", "counts", "file", "in", "XML", "format", ":", "param", "server_url", ":", ":", "param", "instrument_name", ":", ":", "param", "exp_number", ":", ":", "param", "scan_number", ":", ":", "param", "pt_number", ":", ":", "return", ":" ]

[ "def", "get_det_xml_file_url", "(", "server_url", ",", "instrument_name", ",", "exp_number", ",", "scan_number", ",", "pt_number", ")", ":", "assert", "isinstance", "(", "server_url", ",", "str", ")", "and", "isinstance", "(", "instrument_name", ",", "str", ")", "assert", "isinstance", "(", "exp_number", ",", "int", ")", "and", "isinstance", "(", "scan_number", ",", "int", ")", "and", "isinstance", "(", "pt_number", ",", "int", ")", "base_file_name", "=", "get_det_xml_file_name", "(", "instrument_name", ",", "exp_number", ",", "scan_number", ",", "pt_number", ")", "file_url", "=", "'%s/exp%d/Datafiles/%s'", "%", "(", "server_url", ",", "exp_number", ",", "base_file_name", ")", "return", "file_url" ]

[ "Ask", "for", "a", "filename", "to", "open" ]

[ "def", "askopenfilename", "(", "*", "*", "options", ")", ":", "return", "Open", "(", "*", "*", "options", ")", ".", "show", "(", ")" ]

[ "DrawEllipseRect", "(", "self", "Rect", "rect", ")" ]

[ "def", "DrawEllipseRect", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "PseudoDC_DrawEllipseRect", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Find", "the", "program", "*", "ldc2", "*", "and", "set", "the", "variable", "*", "D", "*" ]

[ "def", "find_ldc2", "(", "conf", ")", ":", "conf", ".", "find_program", "(", "[", "'ldc2'", "]", ",", "var", "=", "'D'", ")", "out", "=", "conf", ".", "cmd_and_log", "(", "[", "conf", ".", "env", ".", "D", ",", "'-version'", "]", ")", "if", "out", ".", "find", "(", "\"based on DMD v2.\"", ")", "==", "-", "1", ":", "conf", ".", "fatal", "(", "\"detected compiler is not ldc2\"", ")" ]

[ "Close", "the", "current", "sub", "-", "path", "in", "the", "stroker", "." ]

[ "def", "end_subpath", "(", "self", ")", ":", "error", "=", "FT_Stroker_EndSubPath", "(", "self", ".", "_FT_Stroker", ")", "if", "error", ":", "raise", "FT_Exception", "(", "error", ")" ]

[ "Run", "the", "protocol", "buffer", "compiler", "with", "the", "given", "command", "-", "line", "arguments", "." ]

[ "def", "main", "(", "command_arguments", ")", ":", "command_arguments", "=", "[", "argument", ".", "encode", "(", ")", "for", "argument", "in", "command_arguments", "]", "return", "_protoc_compiler", ".", "run_main", "(", "command_arguments", ")" ]

[ "Return", "the", "color", "(", "red", "green", "blue", ")", "of", "the", "pixel", "at", "X", "Y", "." ]

[ "def", "get", "(", "self", ",", "x", ",", "y", ")", ":", "return", "self", ".", "tk", ".", "call", "(", "self", ".", "name", ",", "'get'", ",", "x", ",", "y", ")" ]

[ "Ask", "for", "a", "filename", "to", "save", "as" ]

[ "def", "asksaveasfilename", "(", "*", "*", "options", ")", ":", "return", "SaveAs", "(", "*", "*", "options", ")", ".", "show", "(", ")" ]

[ "Returns", "True", "if", "the", "object", "is", "an", "operator", "(", "e", ".", "g", ".", "*", "+", "or", "!", ")", "type" ]

[ "def", "isOperation", "(", "self", ")", ":", "return", "False" ]

[ "Tag", ":", "\\", "@opcopytests", "Value", ":", "<opstat", "|", "function", ">", "[", "..", "]", "Example", ":", "\\", "@opcopytests", "add_Eb_Gb" ]

[ "def", "parseTagOpCopyTests", "(", "self", ",", "sTag", ",", "aasSections", ",", "iTagLine", ",", "iEndLine", ")", ":", "oInstr", "=", "self", ".", "ensureInstructionForOpTag", "(", "iTagLine", ")", "# Flatten, validate and append the copy job to the instruction. We execute", "# them after parsing all the input so we can handle forward references.", "asToCopy", "=", "self", ".", "flattenAllSections", "(", "aasSections", ")", ".", "split", "(", ")", "if", "not", "asToCopy", ":", "return", "self", ".", "errorComment", "(", "iTagLine", ",", "'%s: requires at least on reference value'", "%", "(", "sTag", ",", ")", ")", "for", "sToCopy", "in", "asToCopy", ":", "if", "sToCopy", "not", "in", "oInstr", ".", "asCopyTests", ":", "if", "self", ".", "oReStatsName", ".", "match", "(", "sToCopy", ")", "or", "self", ".", "oReFunctionName", ".", "match", "(", "sToCopy", ")", ":", "oInstr", ".", "asCopyTests", ".", "append", "(", "sToCopy", ")", "else", ":", "self", ".", "errorComment", "(", "iTagLine", ",", "'%s: invalid instruction reference (opstat or function) \"%s\" (valid: %s or %s)'", "%", "(", "sTag", ",", "sToCopy", ",", "self", ".", "oReStatsName", ".", "pattern", ",", "self", ".", "oReFunctionName", ".", "pattern", ")", ")", "else", ":", "self", ".", "errorComment", "(", "iTagLine", ",", "'%s: ignoring duplicate \"%s\"'", "%", "(", "sTag", ",", "sToCopy", ",", ")", ")", "_", "=", "iEndLine", "return", "True" ]

[ "Return", "top", "-", "k", "predictions", "for", "the", "dataset", "using", "the", "trained", "model", ".", "Predictions", "are", "returned", "as", "an", "SFrame", "with", "three", "columns", ":", "id", "class", "and", "probability", "margin", "or", "rank", "depending", "on", "the", "output_type", "parameter", ".", "Input", "dataset", "size", "must", "be", "the", "same", "as", "for", "training", "of", "the", "model", "." ]

[ "def", "predict_topk", "(", "self", ",", "dataset", ",", "output_type", "=", "\"probability\"", ",", "k", "=", "3", ",", "missing_value_action", "=", "\"auto\"", ")", ":", "_check_categorical_option_type", "(", "\"output_type\"", ",", "output_type", ",", "[", "\"rank\"", ",", "\"margin\"", ",", "\"probability\"", "]", ")", "_check_categorical_option_type", "(", "\"missing_value_action\"", ",", "missing_value_action", ",", "[", "\"auto\"", ",", "\"impute\"", ",", "\"error\"", "]", ")", "if", "missing_value_action", "==", "\"auto\"", ":", "missing_value_action", "=", "\"impute\"", "# Low latency path", "if", "isinstance", "(", "dataset", ",", "list", ")", ":", "return", "self", ".", "__proxy__", ".", "fast_predict_topk", "(", "dataset", ",", "missing_value_action", ",", "output_type", ",", "k", ")", "if", "isinstance", "(", "dataset", ",", "dict", ")", ":", "return", "self", ".", "__proxy__", ".", "fast_predict_topk", "(", "[", "dataset", "]", ",", "missing_value_action", ",", "output_type", ",", "k", ")", "# Fast path", "_raise_error_if_not_sframe", "(", "dataset", ",", "\"dataset\"", ")", "if", "missing_value_action", "==", "\"auto\"", ":", "missing_value_action", "=", "_sl", ".", "select_default_missing_value_policy", "(", "self", ",", "\"predict\"", ")", "return", "self", ".", "__proxy__", ".", "predict_topk", "(", "dataset", ",", "missing_value_action", ",", "output_type", ",", "k", ")" ]

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

[ "def", "IsSelected", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "TreeCtrl_IsSelected", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "the", "hamming", "distance", "of", "two", "binary", "strings", "." ]

[ "def", "simple_distance_binary", "(", "bin_a", ",", "bin_b", ")", ":", "assert", "len", "(", "bin_a", ")", "==", "BITS_IN_PDQ", "assert", "len", "(", "bin_b", ")", "==", "BITS_IN_PDQ", "return", "sum", "(", "bin_a", "[", "i", "]", "!=", "bin_b", "[", "i", "]", "for", "i", "in", "range", "(", "BITS_IN_PDQ", ")", ")" ]

[ "SetSelectedImage", "(", "self", "int", "image", ")" ]

[ "def", "SetSelectedImage", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListColumnInfo_SetSelectedImage", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Set", "resizemode", "to", "one", "of", "the", "values", ":", "auto", "user", "noresize", "." ]

[ "def", "resizemode", "(", "self", ",", "rmode", "=", "None", ")", ":", "if", "rmode", "is", "None", ":", "return", "self", ".", "_resizemode", "rmode", "=", "rmode", ".", "lower", "(", ")", "if", "rmode", "in", "[", "\"auto\"", ",", "\"user\"", ",", "\"noresize\"", "]", ":", "self", ".", "pen", "(", "resizemode", "=", "rmode", ")" ]

[ "Check", "whether", "the", "character", "is", "part", "of", "MathematicalOperators", "UCS", "Block" ]

[ "def", "uCSIsMathematicalOperators", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsMathematicalOperators", "(", "code", ")", "return", "ret" ]

[ "SetPrintMode", "(", "self", "int", "mode", ")" ]

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

[ "SetDropDownClicked", "(", "self", "bool", "c", ")" ]

[ "def", "SetDropDownClicked", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBarEvent_SetDropDownClicked", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Reads", "the", "value", "of", "this", "variable", "sparsely", "using", "gather", "." ]

[ "def", "sparse_read", "(", "self", ",", "indices", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "\"Gather\"", "if", "name", "is", "None", "else", "name", ")", "as", "name", ":", "if", "self", ".", "_trainable", ":", "tape", ".", "watch_variable", "(", "self", ")", "value", "=", "gen_resource_variable_ops", ".", "resource_gather", "(", "self", ".", "_handle", ",", "indices", ",", "dtype", "=", "self", ".", "_dtype", ",", "name", "=", "name", ")", "return", "array_ops", ".", "identity", "(", "value", ")" ]

[ "Does", "the", "package", "s", "distribution", "contain", "the", "named", "metadata?" ]

[ "def", "has_metadata", "(", "name", ")", ":" ]

[ "Create", "translation", "model", "and", "initialize", "or", "load", "parameters", "in", "session", "." ]

[ "def", "create_model", "(", "session", ",", "forward_only", ")", ":", "model", "=", "seq2seq_model", ".", "Seq2SeqModel", "(", "FLAGS", ".", "en_vocab_size", ",", "FLAGS", ".", "fr_vocab_size", ",", "_buckets", ",", "FLAGS", ".", "size", ",", "FLAGS", ".", "num_layers", ",", "FLAGS", ".", "max_gradient_norm", ",", "FLAGS", ".", "batch_size", ",", "FLAGS", ".", "learning_rate", ",", "FLAGS", ".", "learning_rate_decay_factor", ",", "forward_only", "=", "forward_only", ")", "ckpt", "=", "tf", ".", "train", ".", "get_checkpoint_state", "(", "FLAGS", ".", "train_dir", ")", "if", "ckpt", "and", "tf", ".", "gfile", ".", "Exists", "(", "ckpt", ".", "model_checkpoint_path", ")", ":", "print", "(", "\"Reading model parameters from %s\"", "%", "ckpt", ".", "model_checkpoint_path", ")", "model", ".", "saver", ".", "restore", "(", "session", ",", "ckpt", ".", "model_checkpoint_path", ")", "else", ":", "print", "(", "\"Created model with fresh parameters.\"", ")", "session", ".", "run", "(", "tf", ".", "initialize_all_variables", "(", ")", ")", "return", "model" ]

[ "Creates", "a", "Property", "from", "JSON", "." ]

[ "def", "__init__", "(", "self", ",", "parent", ",", "name", ",", "json", ",", "namespace", ",", "origin", ")", ":", "self", ".", "parent", "=", "parent", "self", ".", "name", "=", "name", "self", ".", "_unix_name", "=", "UnixName", "(", "self", ".", "name", ")", "self", ".", "_unix_name_used", "=", "False", "self", ".", "origin", "=", "origin", "self", ".", "simple_name", "=", "_StripNamespace", "(", "self", ".", "name", ",", "namespace", ")", "self", ".", "description", "=", "json", ".", "get", "(", "'description'", ",", "None", ")", "self", ".", "optional", "=", "json", ".", "get", "(", "'optional'", ",", "None", ")", "self", ".", "instance_of", "=", "json", ".", "get", "(", "'isInstanceOf'", ",", "None", ")", "self", ".", "deprecated", "=", "json", ".", "get", "(", "'deprecated'", ")", "# HACK: only support very specific value types.", "is_allowed_value", "=", "(", "'$ref'", "not", "in", "json", "and", "(", "'type'", "not", "in", "json", "or", "json", "[", "'type'", "]", "==", "'integer'", "or", "json", "[", "'type'", "]", "==", "'string'", ")", ")", "self", ".", "value", "=", "None", "if", "'value'", "in", "json", "and", "is_allowed_value", ":", "self", ".", "value", "=", "json", "[", "'value'", "]", "if", "'type'", "not", "in", "json", ":", "# Sometimes the type of the value is left out, and we need to figure", "# it out for ourselves.", "if", "isinstance", "(", "self", ".", "value", ",", "int", ")", ":", "json", "[", "'type'", "]", "=", "'integer'", "elif", "isinstance", "(", "self", ".", "value", ",", "basestring", ")", ":", "json", "[", "'type'", "]", "=", "'string'", "else", ":", "# TODO(kalman): support more types as necessary.", "raise", "ParseException", "(", "parent", ",", "'\"%s\" is not a supported type for \"value\"'", "%", "type", "(", "self", ".", "value", ")", ")", "self", ".", "type_", "=", "Type", "(", "parent", ",", "name", ",", "json", ",", "namespace", ",", "origin", ")" ]

[ "Get", "a", "set", "of", "tags", "this", "task", "has", "been", "marked", "with", "." ]

[ "def", "tags", "(", "self", ")", ":", "if", "self", ".", "_tags", "is", "None", ":", "self", ".", "_tags", "=", "set", "(", "self", ".", "raw", ".", "get", "(", "\"tags\"", ",", "[", "]", ")", ")", "return", "self", ".", "_tags" ]

[]

[ "def", "reduce", "(", "tensor", ",", "dst", ",", "op", "=", "ReduceOp", ".", "SUM", ",", "group", "=", "None", ",", "use_calc_stream", "=", "True", ")", ":", "if", "group", "is", "not", "None", "and", "not", "group", ".", "is_member", "(", ")", ":", "return", "if", "not", "isinstance", "(", "dst", ",", "int", ")", ":", "raise", "ValueError", "(", "\"dst should be int.\"", ")", "ring_id", "=", "0", "if", "group", "is", "None", "else", "group", ".", "id", "gdst", "=", "dst", "if", "group", "is", "None", "else", "group", ".", "get_group_rank", "(", "dst", ")", "assert", "gdst", ">=", "0", ",", "(", "\"dst rank out of group, need global rank\"", ")", "if", "in_dygraph_mode", "(", ")", ":", "if", "op", "==", "ReduceOp", ".", "SUM", ":", "return", "_C_ops", ".", "c_reduce_sum", "(", "tensor", ",", "tensor", ",", "'use_calc_stream'", ",", "use_calc_stream", ",", "'ring_id'", ",", "ring_id", ",", "'root_id'", ",", "gdst", ")", "elif", "op", "==", "ReduceOp", ".", "MAX", ":", "return", "_C_ops", ".", "c_reduce_max", "(", "tensor", ",", "tensor", ",", "'use_calc_stream'", ",", "use_calc_stream", ",", "'ring_id'", ",", "ring_id", ",", "'root_id'", ",", "gdst", ")", "elif", "op", "==", "ReduceOp", ".", "MIN", ":", "return", "_C_ops", ".", "c_reduce_min", "(", "tensor", ",", "tensor", ",", "'use_calc_stream'", ",", "use_calc_stream", ",", "'ring_id'", ",", "ring_id", ",", "'root_id'", ",", "gdst", ")", "elif", "op", "==", "ReduceOp", ".", "PROD", ":", "return", "_C_ops", ".", "c_reduce_prod", "(", "tensor", ",", "tensor", ",", "'use_calc_stream'", ",", "use_calc_stream", ",", "'ring_id'", ",", "ring_id", ",", "'root_id'", ",", "gdst", ")", "else", ":", "raise", "ValueError", "(", "\"Unknown parameter: {}.\"", ".", "format", "(", "op", ")", ")", "op_type", "=", "'c_reduce'", "check_variable_and_dtype", "(", "tensor", ",", "'tensor'", ",", "[", "'float16'", ",", "'float32'", ",", "'float64'", ",", "'int32'", ",", "'int64'", "]", ",", "'all_reduce'", ")", "if", "not", "op", "in", "[", "ReduceOp", ".", "SUM", ",", "ReduceOp", ".", "MAX", ",", "ReduceOp", ".", "MIN", ",", "ReduceOp", ".", "PROD", "]", ":", "raise", "ValueError", "(", "\"The op for reduce must be one of educeOp.PROD, \"", "\"ReduceOp.SUM, ReduceOp.MAX, ReduceOp.MIN.\"", ")", "if", "op", "==", "ReduceOp", ".", "SUM", ":", "op_type", "=", "'c_reduce_sum'", "elif", "op", "==", "ReduceOp", ".", "MAX", ":", "op_type", "=", "'c_reduce_max'", "elif", "op", "==", "ReduceOp", ".", "MIN", ":", "op_type", "=", "'c_reduce_min'", "elif", "op", "==", "ReduceOp", ".", "PROD", ":", "op_type", "=", "'c_reduce_prod'", "helper", "=", "LayerHelper", "(", "op_type", ",", "*", "*", "locals", "(", ")", ")", "helper", ".", "append_op", "(", "type", "=", "op_type", ",", "inputs", "=", "{", "'X'", ":", "[", "tensor", "]", "}", ",", "outputs", "=", "{", "'Out'", ":", "[", "tensor", "]", "}", ",", "attrs", "=", "{", "'ring_id'", ":", "ring_id", ",", "'use_calc_stream'", ":", "use_calc_stream", ",", "'root_id'", ":", "gdst", ",", "}", ")" ]

[ "Returns", "the", "dot", "product", "of", "two", "arrays", "." ]

[ "def", "dot", "(", "a", ",", "b", ")", ":", "ndim_a", ",", "ndim_b", "=", "F", ".", "rank", "(", "a", ")", ",", "F", ".", "rank", "(", "b", ")", "if", "ndim_a", "==", "0", "or", "ndim_b", "==", "0", ":", "return", "F", ".", "tensor_mul", "(", "a", ",", "b", ")", "if", "ndim_a", ">", "0", "and", "ndim_b", ">=", "2", ":", "perm", "=", "F", ".", "make_range", "(", "ndim_b", ")", "perm", "=", "perm", "[", ":", "-", "2", "]", "+", "(", "perm", "[", "-", "1", "]", ",", ")", "+", "(", "perm", "[", "-", "2", "]", ",", ")", "b", "=", "F", ".", "transpose", "(", "b", ",", "perm", ")", "if", "F", ".", "shape", "(", "a", ")", "[", "-", "1", "]", "!=", "F", ".", "shape", "(", "b", ")", "[", "-", "1", "]", ":", "_raise_value_error", "(", "'shapes are not aligned'", ")", "a_aligned", "=", "F", ".", "reshape", "(", "a", ",", "(", "-", "1", ",", "F", ".", "shape", "(", "a", ")", "[", "-", "1", "]", ")", ")", "b_aligned", "=", "F", ".", "reshape", "(", "b", ",", "(", "-", "1", ",", "F", ".", "shape", "(", "b", ")", "[", "-", "1", "]", ")", ")", "res", "=", "_matmul_t", "(", "a_aligned", ",", "b_aligned", ")", "res", "=", "F", ".", "reshape", "(", "res", ",", "F", ".", "shape", "(", "a", ")", "[", ":", "-", "1", "]", "+", "F", ".", "shape", "(", "b", ")", "[", ":", "-", "1", "]", ")", "return", "res" ]

[ "GetFont", "(", "self", "int", "item", ")", "-", ">", "Font" ]

[ "def", "GetFont", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "StockGDI_GetFont", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Implementation", "of", "^", "operator", "when", "left", "operand", "is", "not", "a", "C", "{", "L", "{", "ParserElement", "}}" ]

[ "def", "__rxor__", "(", "self", ",", "other", ")", ":", "if", "isinstance", "(", "other", ",", "basestring", ")", ":", "other", "=", "ParserElement", ".", "_literalStringClass", "(", "other", ")", "if", "not", "isinstance", "(", "other", ",", "ParserElement", ")", ":", "warnings", ".", "warn", "(", "\"Cannot combine element of type %s with ParserElement\"", "%", "type", "(", "other", ")", ",", "SyntaxWarning", ",", "stacklevel", "=", "2", ")", "return", "None", "return", "other", "^", "self" ]

[ "Run", "net", "forward", "+", "backward", "in", "batches", "." ]

[ "def", "_Net_forward_backward_all", "(", "self", ",", "blobs", "=", "None", ",", "diffs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "# Batch blobs and diffs.", "all_outs", "=", "{", "out", ":", "[", "]", "for", "out", "in", "set", "(", "self", ".", "outputs", "+", "(", "blobs", "or", "[", "]", ")", ")", "}", "all_diffs", "=", "{", "diff", ":", "[", "]", "for", "diff", "in", "set", "(", "self", ".", "inputs", "+", "(", "diffs", "or", "[", "]", ")", ")", "}", "forward_batches", "=", "self", ".", "_batch", "(", "{", "in_", ":", "kwargs", "[", "in_", "]", "for", "in_", "in", "self", ".", "inputs", "if", "in_", "in", "kwargs", "}", ")", "backward_batches", "=", "self", ".", "_batch", "(", "{", "out", ":", "kwargs", "[", "out", "]", "for", "out", "in", "self", ".", "outputs", "if", "out", "in", "kwargs", "}", ")", "# Collect outputs from batches (and heed lack of forward/backward batches).", "for", "fb", ",", "bb", "in", "izip_longest", "(", "forward_batches", ",", "backward_batches", ",", "fillvalue", "=", "{", "}", ")", ":", "batch_blobs", "=", "self", ".", "forward", "(", "blobs", "=", "blobs", ",", "*", "*", "fb", ")", "batch_diffs", "=", "self", ".", "backward", "(", "diffs", "=", "diffs", ",", "*", "*", "bb", ")", "for", "out", ",", "out_blobs", "in", "six", ".", "iteritems", "(", "batch_blobs", ")", ":", "all_outs", "[", "out", "]", ".", "extend", "(", "out_blobs", ".", "copy", "(", ")", ")", "for", "diff", ",", "out_diffs", "in", "six", ".", "iteritems", "(", "batch_diffs", ")", ":", "all_diffs", "[", "diff", "]", ".", "extend", "(", "out_diffs", ".", "copy", "(", ")", ")", "# Package in ndarray.", "for", "out", ",", "diff", "in", "zip", "(", "all_outs", ",", "all_diffs", ")", ":", "all_outs", "[", "out", "]", "=", "np", ".", "asarray", "(", "all_outs", "[", "out", "]", ")", "all_diffs", "[", "diff", "]", "=", "np", ".", "asarray", "(", "all_diffs", "[", "diff", "]", ")", "# Discard padding at the end and package in ndarray.", "pad", "=", "len", "(", "six", ".", "next", "(", "six", ".", "itervalues", "(", "all_outs", ")", ")", ")", "-", "len", "(", "six", ".", "next", "(", "six", ".", "itervalues", "(", "kwargs", ")", ")", ")", "if", "pad", ":", "for", "out", ",", "diff", "in", "zip", "(", "all_outs", ",", "all_diffs", ")", ":", "all_outs", "[", "out", "]", "=", "all_outs", "[", "out", "]", "[", ":", "-", "pad", "]", "all_diffs", "[", "diff", "]", "=", "all_diffs", "[", "diff", "]", "[", ":", "-", "pad", "]", "return", "all_outs", ",", "all_diffs" ]

[ "send", "a", "MAVLink", "message" ]

[ "def", "send", "(", "self", ",", "mavmsg", ")", ":", "buf", "=", "mavmsg", ".", "pack", "(", "self", ")", "self", ".", "file", ".", "write", "(", "buf", ")", "self", ".", "seq", "=", "(", "self", ".", "seq", "+", "1", ")", "%", "255", "self", ".", "total_packets_sent", "+=", "1", "self", ".", "total_bytes_sent", "+=", "len", "(", "buf", ")" ]

[ "Returns", "first", "function", "that", "matches", "*", "py_func", "*", "and", "the", "arguments", "types", "in", "*", "args", "*", ";", "or", "None", "if", "no", "match", "." ]

[ "def", "match", "(", "self", ",", "py_func", ",", "args", ")", ":", "for", "frame", "in", "self", ".", "finditer", "(", "py_func", ")", ":", "if", "frame", ".", "args", "==", "args", ":", "return", "frame" ]

[ "Report", "if", "too", "many", "lines", "in", "function", "body", "." ]

[ "def", "Check", "(", "self", ",", "error", ",", "filename", ",", "linenum", ")", ":", "if", "Match", "(", "r'T(EST|est)'", ",", "self", ".", "current_function", ")", ":", "base_trigger", "=", "self", ".", "_TEST_TRIGGER", "else", ":", "base_trigger", "=", "self", ".", "_NORMAL_TRIGGER", "trigger", "=", "base_trigger", "*", "2", "**", "_VerboseLevel", "(", ")", "if", "self", ".", "lines_in_function", ">", "trigger", ":", "error_level", "=", "int", "(", "math", ".", "log", "(", "self", ".", "lines_in_function", "/", "base_trigger", ",", "2", ")", ")", "# 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...", "if", "error_level", ">", "5", ":", "error_level", "=", "5", "error", "(", "filename", ",", "linenum", ",", "'readability/fn_size'", ",", "error_level", ",", "'Small and focused functions are preferred:'", "' %s has %d non-comment lines'", "' (error triggered by exceeding %d lines).'", "%", "(", "self", ".", "current_function", ",", "self", ".", "lines_in_function", ",", "trigger", ")", ")" ]