Datasets:

Denis641

/

CodeGenDataset

like 0

[ "def", "_inplace_sort_by_id", "(", "unsorted_list", ")", ":", "if", "not", "isinstance", "(", "unsorted_list", ",", "list", ")", ":", "return", "sorted_list", "=", "[", "(", "i", ".", "get", "(", "'@id'", ")", ",", "i", ")", "for", "i", "in", "unsorted_list", "]", "sorted_list", ".", "sort", "(", ")", "del", "unsorted_list", "[", ":", "]", "unsorted_list", ".", "extend", "(", "[", "i", "[", "1", "]", "for", "i", "in", "sorted_list", "]", ")" ]

[ "Takes", "a", "list", "of", "dicts", "each", "of", "which", "has", "an" ]

[ "def", "cull_nonmatching_trees", "(", "nexson", ",", "tree_id", ",", "curr_version", "=", "None", ")", ":", "if", "curr_version", "is", "None", ":", "curr_version", "=", "detect_nexson_version", "(", "nexson", ")", "if", "not", "_is_by_id_hbf", "(", "curr_version", ")", ":", "nexson", "=", "convert_nexson_format", "(", "nexson", ",", "BY_ID_HONEY_BADGERFISH", ")", "nexml_el", "=", "get_nexml_el", "(", "nexson", ")", "tree_groups", "=", "nexml_el", "[", "'treesById'", "]", "tree_groups_to_del", "=", "[", "]", "for", "tgi", ",", "tree_group", "in", "tree_groups", ".", "items", "(", ")", ":", "tbi", "=", "tree_group", "[", "'treeById'", "]", "if", "tree_id", "in", "tbi", ":", "trees_to_del", "=", "[", "i", "for", "i", "in", "tbi", ".", "keys", "(", ")", "if", "i", "!=", "tree_id", "]", "for", "tid", "in", "trees_to_del", ":", "tree_group", "[", "'^ot:treeElementOrder'", "]", ".", "remove", "(", "tid", ")", "del", "tbi", "[", "tid", "]", "else", ":", "tree_groups_to_del", ".", "append", "(", "tgi", ")", "for", "tgid", "in", "tree_groups_to_del", ":", "nexml_el", "[", "'^ot:treesElementOrder'", "]", ".", "remove", "(", "tgid", ")", "del", "tree_groups", "[", "tgid", "]", "return", "nexson" ]

[ "Modifies", "nexson", "and", "returns", "it", "in", "version", "1", ".", "2", ".", "1", "with", "any", "tree", "that", "does", "not", "match", "the", "ID", "removed", "." ]

[ "def", "phylesystem_api_url", "(", "self", ",", "base_url", ",", "study_id", ")", ":", "p", "=", "self", ".", "_phylesystem_api_params", "(", ")", "e", "=", "self", ".", "_phylesystem_api_ext", "(", ")", "if", "self", ".", "content", "==", "'study'", ":", "return", "'{d}/study/{i}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'tree'", ":", "if", "self", ".", "content_id", "is", "None", ":", "return", "'{d}/study/{i}/tree{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "return", "'{d}/study/{i}/tree/{t}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "t", "=", "self", ".", "content_id", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'subtree'", ":", "assert", "self", ".", "content_id", "is", "not", "None", "t", ",", "n", "=", "self", ".", "content_id", "p", "[", "'subtree_id'", "]", "=", "n", "return", "'{d}/study/{i}/subtree/{t}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "t", "=", "t", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'meta'", ":", "return", "'{d}/study/{i}/meta{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'otus'", ":", "if", "self", ".", "content_id", "is", "None", ":", "return", "'{d}/study/{i}/otus{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "return", "'{d}/study/{i}/otus/{t}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "t", "=", "self", ".", "content_id", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'otu'", ":", "if", "self", ".", "content_id", "is", "None", ":", "return", "'{d}/study/{i}/otu{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "return", "'{d}/study/{i}/otu/{t}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "t", "=", "self", ".", "content_id", ",", "e", "=", "e", ")", ",", "p", "elif", "self", ".", "content", "==", "'otumap'", ":", "return", "'{d}/otumap/{i}{e}'", ".", "format", "(", "d", "=", "base_url", ",", "i", "=", "study_id", ",", "e", "=", "e", ")", ",", "p", "else", ":", "assert", "False" ]

[ "Returns", "URL", "and", "param", "dict", "for", "a", "GET", "call", "to", "phylesystem_api" ]

[ "def", "_is_valid", "(", "self", ",", "log", ":", "Optional", "[", "Logger", "]", "=", "None", ")", "->", "bool", ":", "return", "self", ".", "_validate", "(", "self", ",", "log", ")", "[", "0", "]" ]

[ "Determine", "whether", "the", "current", "contents", "are", "valid" ]

[ "def", "_validate", "(", "self", ",", "val", ":", "list", ",", "log", ":", "Optional", "[", "Logger", "]", "=", "None", ")", "->", "Tuple", "[", "bool", ",", "List", "[", "str", "]", "]", ":", "errors", "=", "[", "]", "if", "not", "isinstance", "(", "val", ",", "list", ")", ":", "errors", ".", "append", "(", "f\"{self._variable_name}: {repr(val)} is not an array\"", ")", "else", ":", "for", "i", "in", "range", "(", "0", ",", "len", "(", "val", ")", ")", ":", "v", "=", "val", "[", "i", "]", "if", "not", "conforms", "(", "v", ",", "self", ".", "_type", ",", "self", ".", "_context", ".", "NAMESPACE", ")", ":", "errors", ".", "append", "(", "f\"{self._variable_name} element {i}: {v} is not a {self._type.__name__}\"", ")", "if", "len", "(", "val", ")", "<", "self", ".", "_min", ":", "errors", ".", "append", "(", "f\"{self._variable_name}: at least {self._min} value{'s' if self._min > 1 else ''} required - \"", "f\"element has {len(val) if len(val) else 'none'}\"", ")", "if", "self", ".", "_max", "is", "not", "None", "and", "len", "(", "val", ")", ">", "self", ".", "_max", ":", "errors", ".", "append", "(", "f\"{self._variable_name}: no more than {self._max} values permitted - element has {len(val)}\"", ")", "if", "log", ":", "for", "error", "in", "errors", ":", "log", ".", "log", "(", "error", ")", "return", "not", "bool", "(", "errors", ")", ",", "errors" ]

[ "Determine", "whether", "val", "is", "a", "valid", "instance", "of", "this", "array" ]

[ "def", "tree_iter_nexson_proxy", "(", "nexson_proxy", ")", ":", "nexml_el", "=", "nexson_proxy", ".", "_nexml_el", "tg_order", "=", "nexml_el", "[", "'^ot:treesElementOrder'", "]", "tgd", "=", "nexml_el", "[", "'treesById'", "]", "for", "tg_id", "in", "tg_order", ":", "tg", "=", "tgd", "[", "tg_id", "]", "tree_order", "=", "tg", "[", "'^ot:treeElementOrder'", "]", "tbid", "=", "tg", "[", "'treeById'", "]", "otus", "=", "tg", "[", "'@otus'", "]", "for", "k", "in", "tree_order", ":", "v", "=", "tbid", "[", "k", "]", "yield", "nexson_proxy", ".", "_create_tree_proxy", "(", "tree_id", "=", "k", ",", "tree", "=", "v", ",", "otus", "=", "otus", ")" ]

[ "Iterates", "over", "NexsonTreeProxy", "objects", "in", "order", "determined", "by", "the", "nexson", "blob" ]

[ "def", "main", "(", ")", ":", "# No need to use \"proper\" names on such simple code.", "# pylint: disable=invalid-name", "p", "=", "argparse", ".", "ArgumentParser", "(", ")", "p", ".", "add_argument", "(", "\"--host\"", ",", "default", "=", "\"localhost\"", ")", "p", ".", "add_argument", "(", "\"--port\"", ",", "type", "=", "int", ",", "default", "=", "3551", ")", "p", ".", "add_argument", "(", "\"--strip-units\"", ",", "action", "=", "\"store_true\"", ",", "default", "=", "False", ")", "args", "=", "p", ".", "parse_args", "(", ")", "status", ".", "print_status", "(", "status", ".", "get", "(", "args", ".", "host", ",", "args", ".", "port", ")", ",", "strip_units", "=", "args", ".", "strip_units", ")" ]

[ "Get", "status", "from", "APC", "NIS", "and", "print", "output", "on", "stdout", "." ]

[ "def", "wsgi_app", "(", "self", ",", "environ", ",", "start_response", ")", ":", "@", "_LOCAL_MANAGER", ".", "middleware", "def", "_wrapped_app", "(", "environ", ",", "start_response", ")", ":", "request", "=", "Request", "(", "environ", ")", "setattr", "(", "_local", ",", "_CURRENT_REQUEST_KEY", ",", "request", ")", "response", "=", "self", ".", "_dispatch_request", "(", "request", ")", "return", "response", "(", "environ", ",", "start_response", ")", "return", "_wrapped_app", "(", "environ", ",", "start_response", ")" ]

[ "A", "basic", "WSGI", "app" ]

[ "def", "run", "(", "self", ",", "host", ",", "port", ",", "*", "*", "options", ")", ":", "self", ".", "registry", ".", "debug", "=", "True", "debugged", "=", "DebuggedJsonRpcApplication", "(", "self", ",", "evalex", "=", "True", ")", "run_simple", "(", "host", ",", "port", ",", "debugged", ",", "use_reloader", "=", "True", ",", "*", "*", "options", ")" ]

[ "For", "debugging", "purposes", "you", "can", "run", "this", "as", "a", "standalone", "server", "." ]

[ "def", "_try_trigger_before_first_request_funcs", "(", "self", ")", ":", "# pylint: disable=C0103", "if", "self", ".", "_after_first_request_handled", ":", "return", "else", ":", "with", "self", ".", "_before_first_request_lock", ":", "if", "self", ".", "_after_first_request_handled", ":", "return", "for", "func", "in", "self", ".", "_before_first_request_funcs", ":", "func", "(", ")", "self", ".", "_after_first_request_handled", "=", "True" ]

[ "Runs", "each", "function", "from", "self", ".", "before_first_request_funcs", "once", "and", "only", "once", "." ]

[ "def", "debug_application", "(", "self", ",", "environ", ",", "start_response", ")", ":", "adapter", "=", "self", ".", "_debug_map", ".", "bind_to_environ", "(", "environ", ")", "if", "adapter", ".", "test", "(", ")", ":", "_", ",", "args", "=", "adapter", ".", "match", "(", ")", "return", "self", ".", "handle_debug", "(", "environ", ",", "start_response", ",", "args", "[", "\"traceback_id\"", "]", ")", "else", ":", "return", "super", "(", "DebuggedJsonRpcApplication", ",", "self", ")", ".", "debug_application", "(", "environ", ",", "start_response", ")" ]

[ "Run", "the", "application", "and", "preserve", "the", "traceback", "frames", "." ]

[ "def", "handle_debug", "(", "self", ",", "environ", ",", "start_response", ",", "traceback_id", ")", ":", "if", "traceback_id", "not", "in", "self", ".", "app", ".", "registry", ".", "tracebacks", ":", "abort", "(", "404", ")", "self", ".", "_copy_over_traceback", "(", "traceback_id", ")", "traceback", "=", "self", ".", "tracebacks", "[", "traceback_id", "]", "rendered", "=", "traceback", ".", "render_full", "(", "evalex", "=", "self", ".", "evalex", ",", "secret", "=", "self", ".", "secret", ")", "response", "=", "Response", "(", "rendered", ".", "encode", "(", "'utf-8'", ",", "'replace'", ")", ",", "headers", "=", "[", "(", "'Content-Type'", ",", "'text/html; charset=utf-8'", ")", ",", "(", "'X-XSS-Protection'", ",", "'0'", ")", "]", ")", "return", "response", "(", "environ", ",", "start_response", ")" ]

[ "Handles", "the", "debug", "endpoint", "for", "inspecting", "previous", "errors", "." ]

[ "def", "register_signals", "(", "self", ",", "app", ")", ":", "before_record_index", ".", "connect", "(", "inject_provisional_community", ")", "if", "app", ".", "config", "[", "'COMMUNITIES_OAI_ENABLED'", "]", ":", "listen", "(", "Community", ",", "'after_insert'", ",", "create_oaipmh_set", ")", "listen", "(", "Community", ",", "'after_delete'", ",", "destroy_oaipmh_set", ")", "inclusion_request_created", ".", "connect", "(", "new_request", ")" ]

[ "Register", "the", "signals", "." ]

[ "def", "genargs", "(", ")", "->", "ArgumentParser", ":", "parser", "=", "ArgumentParser", "(", ")", "parser", ".", "add_argument", "(", "\"spec\"", ",", "help", "=", "\"JSG specification - can be file name, URI or string\"", ")", "parser", ".", "add_argument", "(", "\"-o\"", ",", "\"--outfile\"", ",", "help", "=", "\"Output python file - if omitted, python is not saved\"", ")", "parser", ".", "add_argument", "(", "\"-p\"", ",", "\"--print\"", ",", "help", "=", "\"Print python file to stdout\"", ")", "parser", ".", "add_argument", "(", "\"-id\"", ",", "\"--inputdir\"", ",", "help", "=", "\"Input directory with JSON files\"", ")", "parser", ".", "add_argument", "(", "\"-i\"", ",", "\"--json\"", ",", "help", "=", "\"URL, file name or json text\"", ",", "nargs", "=", "'*'", ")", "return", "parser" ]

[ "Create", "a", "command", "line", "parser" ]

[ "def", "_to_string", "(", "inp", ":", "str", ")", "->", "str", ":", "if", "'://'", "in", "inp", ":", "req", "=", "requests", ".", "get", "(", "inp", ")", "if", "not", "req", ".", "ok", ":", "raise", "ValueError", "(", "f\"Unable to read {inp}\"", ")", "return", "req", ".", "text", "else", ":", "with", "open", "(", "inp", ")", "as", "infile", ":", "return", "infile", ".", "read", "(", ")" ]

[ "Convert", "a", "URL", "or", "file", "name", "to", "a", "string" ]

[ "def", "conforms", "(", "self", ",", "json", ":", "str", ",", "name", ":", "str", "=", "\"\"", ",", "verbose", ":", "bool", "=", "False", ")", "->", "ValidationResult", ":", "json", "=", "self", ".", "_to_string", "(", "json", ")", "if", "not", "self", ".", "is_json", "(", "json", ")", "else", "json", "try", ":", "self", ".", "json_obj", "=", "loads", "(", "json", ",", "self", ".", "module", ")", "except", "ValueError", "as", "v", ":", "return", "ValidationResult", "(", "False", ",", "str", "(", "v", ")", ",", "name", ",", "None", ")", "logfile", "=", "StringIO", "(", ")", "logger", "=", "Logger", "(", "cast", "(", "TextIO", ",", "logfile", ")", ")", "# cast because of bug in ide", "if", "not", "is_valid", "(", "self", ".", "json_obj", ",", "logger", ")", ":", "return", "ValidationResult", "(", "False", ",", "logfile", ".", "getvalue", "(", ")", ".", "strip", "(", "'\\n'", ")", ",", "name", ",", "None", ")", "return", "ValidationResult", "(", "True", ",", "\"\"", ",", "name", ",", "type", "(", "self", ".", "json_obj", ")", ".", "__name__", ")" ]

[ "Determine", "whether", "json", "conforms", "with", "the", "JSG", "specification" ]

[ "async", "def", "_sync_revoc", "(", "self", ",", "rr_id", ":", "str", ",", "rr_size", ":", "int", "=", "None", ")", "->", "None", ":", "LOGGER", ".", "debug", "(", "'Issuer._sync_revoc >>> rr_id: %s, rr_size: %s'", ",", "rr_id", ",", "rr_size", ")", "(", "cd_id", ",", "tag", ")", "=", "rev_reg_id2cred_def_id__tag", "(", "rr_id", ")", "try", ":", "await", "self", ".", "get_cred_def", "(", "cd_id", ")", "except", "AbsentCredDef", ":", "LOGGER", ".", "debug", "(", "'Issuer._sync_revoc: <!< tails tree %s may be for another ledger; no cred def found on %s'", ",", "self", ".", "_dir_tails", ",", "cd_id", ")", "raise", "AbsentCredDef", "(", "'Tails tree {} may be for another ledger; no cred def found on {}'", ".", "format", "(", "self", ".", "_dir_tails", ",", "cd_id", ")", ")", "with", "REVO_CACHE", ".", "lock", ":", "revo_cache_entry", "=", "REVO_CACHE", ".", "get", "(", "rr_id", ",", "None", ")", "tails", "=", "None", "if", "revo_cache_entry", "is", "None", "else", "revo_cache_entry", ".", "tails", "if", "tails", "is", "None", ":", "# it's a new revocation registry, or not yet set in cache", "try", ":", "tails", "=", "await", "Tails", "(", "self", ".", "_dir_tails", ",", "cd_id", ",", "tag", ")", ".", "open", "(", ")", "except", "AbsentTails", ":", "await", "self", ".", "_create_rev_reg", "(", "rr_id", ",", "rr_size", ")", "# it's a new revocation registry", "tails", "=", "await", "Tails", "(", "self", ".", "_dir_tails", ",", "cd_id", ",", "tag", ")", ".", "open", "(", ")", "# symlink should exist now", "if", "revo_cache_entry", "is", "None", ":", "REVO_CACHE", "[", "rr_id", "]", "=", "RevoCacheEntry", "(", "None", ",", "tails", ")", "else", ":", "REVO_CACHE", "[", "rr_id", "]", ".", "tails", "=", "tails", "LOGGER", ".", "debug", "(", "'Issuer._sync_revoc <<<'", ")" ]

[ "Create", "revoc", "registry", "if", "need", "be", "for", "input", "revocation", "registry", "identifier", ";", "open", "and", "cache", "tails", "file", "reader", "." ]

[ "def", "quote_xml", "(", "text", ")", ":", "text", "=", "_coerce_unicode", "(", "text", ")", "# If it's a CDATA block, return the text as is.", "if", "text", ".", "startswith", "(", "CDATA_START", ")", ":", "return", "text", "# If it's not a CDATA block, escape the XML and return the character", "# encoded string.", "return", "saxutils", ".", "escape", "(", "text", ")" ]

[ "Format", "a", "value", "for", "display", "as", "an", "XML", "text", "node", "." ]

[ "def", "__construct_from_components", "(", "self", ",", "ns_uri", ",", "prefix", "=", "None", ",", "schema_location", "=", "None", ")", ":", "assert", "ns_uri", "# other fields are optional", "self", ".", "uri", "=", "ns_uri", "self", ".", "schema_location", "=", "schema_location", "or", "None", "self", ".", "prefixes", "=", "OrderedSet", "(", ")", "if", "prefix", ":", "self", ".", "prefixes", ".", "add", "(", "prefix", ")", "self", ".", "preferred_prefix", "=", "prefix", "or", "None" ]

[ "Initialize", "this", "instance", "from", "a", "namespace", "URI", "and", "optional", "prefix", "and", "schema", "location", "URI", "." ]

[ "def", "namespace_for_prefix", "(", "self", ",", "prefix", ")", ":", "try", ":", "ni", "=", "self", ".", "__lookup_prefix", "(", "prefix", ")", "except", "PrefixNotFoundError", ":", "return", "None", "else", ":", "return", "ni", ".", "uri" ]

[ "Get", "the", "namespace", "the", "given", "prefix", "maps", "to", "." ]

[ "def", "set_preferred_prefix_for_namespace", "(", "self", ",", "ns_uri", ",", "prefix", ",", "add_if_not_exist", "=", "False", ")", ":", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "if", "not", "prefix", ":", "ni", ".", "preferred_prefix", "=", "None", "elif", "prefix", "in", "ni", ".", "prefixes", ":", "ni", ".", "preferred_prefix", "=", "prefix", "elif", "add_if_not_exist", ":", "self", ".", "add_prefix", "(", "ns_uri", ",", "prefix", ",", "set_as_preferred", "=", "True", ")", "else", ":", "raise", "PrefixNotFoundError", "(", "prefix", ")" ]

[ "Sets", "the", "preferred", "prefix", "for", "ns_uri", ".", "If", "add_if_not_exist", "is", "True", "the", "prefix", "is", "added", "if", "it", "s", "not", "already", "registered", ".", "Otherwise", "setting", "an", "unknown", "prefix", "as", "preferred", "is", "an", "error", ".", "The", "default", "is", "False", ".", "Setting", "to", "None", "always", "works", "and", "indicates", "a", "preference", "to", "use", "the", "namespace", "as", "a", "default", ".", "The", "given", "namespace", "must", "already", "be", "in", "this", "set", "." ]

[ "def", "__merge_schema_locations", "(", "self", ",", "ni", ",", "incoming_schemaloc", ")", ":", "if", "ni", ".", "schema_location", "==", "incoming_schemaloc", ":", "# TODO (bworrell): empty strings?", "return", "elif", "not", "ni", ".", "schema_location", ":", "ni", ".", "schema_location", "=", "incoming_schemaloc", "or", "None", "elif", "not", "incoming_schemaloc", ":", "return", "else", ":", "raise", "ConflictingSchemaLocationError", "(", "ni", ".", "uri", ",", "ni", ".", "schema_location", ",", "incoming_schemaloc", ")" ]

[ "Merge", "incoming_schemaloc", "into", "the", "given", "_NamespaceInfo", "ni", ".", "If", "we", "don", "t", "have", "one", "yet", "and", "the", "incoming", "value", "is", "non", "-", "None", "update", "ours", "with", "theirs", ".", "This", "modifies", "ni", "." ]

[ "def", "add_namespace_uri", "(", "self", ",", "ns_uri", ",", "prefix", "=", "None", ",", "schema_location", "=", "None", ")", ":", "assert", "ns_uri", "if", "ns_uri", "in", "self", ".", "__ns_uri_map", ":", "# We have a _NamespaceInfo object for this URI already. So this", "# is a merge operation.", "#", "# We modify a copy of the real _NamespaceInfo so that we are", "# exception-safe: if something goes wrong, we don't end up with a", "# half-changed NamespaceSet.", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "new_ni", "=", "copy", ".", "deepcopy", "(", "ni", ")", "# Reconcile prefixes", "if", "prefix", ":", "self", ".", "__check_prefix_conflict", "(", "ni", ",", "prefix", ")", "new_ni", ".", "prefixes", ".", "add", "(", "prefix", ")", "self", ".", "__merge_schema_locations", "(", "new_ni", ",", "schema_location", ")", "# At this point, we have a legit new_ni object. Now we update", "# the set, ensuring our invariants. This should replace", "# all instances of the old ni in this set.", "for", "p", "in", "new_ni", ".", "prefixes", ":", "self", ".", "__prefix_map", "[", "p", "]", "=", "new_ni", "self", ".", "__ns_uri_map", "[", "new_ni", ".", "uri", "]", "=", "new_ni", "else", ":", "# A brand new namespace. The incoming prefix should not exist at", "# all in the prefix map.", "if", "prefix", ":", "self", ".", "__check_prefix_conflict", "(", "ns_uri", ",", "prefix", ")", "ni", "=", "_NamespaceInfo", "(", "ns_uri", ",", "prefix", ",", "schema_location", ")", "self", ".", "__add_namespaceinfo", "(", "ni", ")" ]

[ "Adds", "a", "new", "namespace", "to", "this", "set", "optionally", "with", "a", "prefix", "and", "schema", "location", "URI", "." ]

[ "def", "remove_namespace", "(", "self", ",", "ns_uri", ")", ":", "if", "not", "self", ".", "contains_namespace", "(", "ns_uri", ")", ":", "return", "ni", "=", "self", ".", "__ns_uri_map", ".", "pop", "(", "ns_uri", ")", "for", "prefix", "in", "ni", ".", "prefixes", ":", "del", "self", ".", "__prefix_map", "[", "prefix", "]" ]

[ "Removes", "the", "indicated", "namespace", "from", "this", "set", "." ]

[ "def", "add_prefix", "(", "self", ",", "ns_uri", ",", "prefix", ",", "set_as_preferred", "=", "False", ")", ":", "assert", "prefix", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "self", ".", "__check_prefix_conflict", "(", "ni", ",", "prefix", ")", "ni", ".", "prefixes", ".", "add", "(", "prefix", ")", "self", ".", "__prefix_map", "[", "prefix", "]", "=", "ni", "if", "set_as_preferred", ":", "ni", ".", "preferred_prefix", "=", "prefix" ]

[ "Adds", "prefix", "for", "the", "given", "namespace", "URI", ".", "The", "namespace", "must", "already", "exist", "in", "this", "set", ".", "If", "set_as_preferred", "is", "True", "also", "set", "this", "namespace", "as", "the", "preferred", "one", "." ]

[ "def", "prefix_iter", "(", "self", ",", "ns_uri", ")", ":", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "return", "iter", "(", "ni", ".", "prefixes", ")" ]

[ "Gets", "an", "iterator", "over", "the", "prefixes", "for", "the", "given", "namespace", "." ]

[ "def", "remove_prefix", "(", "self", ",", "prefix", ")", ":", "if", "prefix", "not", "in", "self", ".", "__prefix_map", ":", "return", "ni", "=", "self", ".", "__lookup_prefix", "(", "prefix", ")", "ni", ".", "prefixes", ".", "discard", "(", "prefix", ")", "del", "self", ".", "__prefix_map", "[", "prefix", "]", "# If we removed the preferred prefix, find a new one.", "if", "ni", ".", "preferred_prefix", "==", "prefix", ":", "ni", ".", "preferred_prefix", "=", "next", "(", "iter", "(", "ni", ".", "prefixes", ")", ",", "None", ")" ]

[ "Removes", "prefix", "from", "this", "set", ".", "This", "is", "a", "no", "-", "op", "if", "the", "prefix", "doesn", "t", "exist", "in", "it", "." ]

[ "def", "set_schema_location", "(", "self", ",", "ns_uri", ",", "schema_location", ",", "replace", "=", "False", ")", ":", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "if", "ni", ".", "schema_location", "==", "schema_location", ":", "return", "elif", "replace", "or", "ni", ".", "schema_location", "is", "None", ":", "ni", ".", "schema_location", "=", "schema_location", "elif", "schema_location", "is", "None", ":", "ni", ".", "schema_location", "=", "None", "# Not considered \"replacement\".", "else", ":", "raise", "ConflictingSchemaLocationError", "(", "ns_uri", ",", "ni", ".", "schema_location", ",", "schema_location", ")" ]

[ "Sets", "the", "schema", "location", "of", "the", "given", "namespace", "." ]

[ "def", "get_schemaloc_string", "(", "self", ",", "ns_uris", "=", "None", ",", "sort", "=", "False", ",", "delim", "=", "\"\\n\"", ")", ":", "if", "not", "ns_uris", ":", "ns_uris", "=", "six", ".", "iterkeys", "(", "self", ".", "__ns_uri_map", ")", "if", "sort", ":", "ns_uris", "=", "sorted", "(", "ns_uris", ")", "schemalocs", "=", "[", "]", "for", "ns_uri", "in", "ns_uris", ":", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "if", "ni", ".", "schema_location", ":", "schemalocs", ".", "append", "(", "\"{0.uri} {0.schema_location}\"", ".", "format", "(", "ni", ")", ")", "if", "not", "schemalocs", ":", "return", "\"\"", "return", "'xsi:schemaLocation=\"{0}\"'", ".", "format", "(", "delim", ".", "join", "(", "schemalocs", ")", ")" ]

[ "Constructs", "and", "returns", "a", "schemalocation", "attribute", ".", "If", "no", "namespaces", "in", "this", "set", "have", "any", "schema", "locations", "defined", "returns", "an", "empty", "string", "." ]

[ "def", "get_uri_prefix_map", "(", "self", ")", ":", "mapping", "=", "{", "}", "for", "ni", "in", "six", ".", "itervalues", "(", "self", ".", "__ns_uri_map", ")", ":", "if", "ni", ".", "preferred_prefix", ":", "mapping", "[", "ni", ".", "uri", "]", "=", "ni", ".", "preferred_prefix", "elif", "len", "(", "ni", ".", "prefixes", ")", ">", "0", ":", "mapping", "[", "ni", ".", "uri", "]", "=", "next", "(", "iter", "(", "ni", ".", "prefixes", ")", ")", "else", ":", "# The reason I don't let any namespace map to None here is that", "# I don't think generateDS supports it. It requires prefixes", "# for all namespaces.", "raise", "NoPrefixesError", "(", "ni", ".", "uri", ")", "return", "mapping" ]

[ "Constructs", "and", "returns", "a", "map", "from", "namespace", "URI", "to", "prefix", "representing", "all", "namespaces", "in", "this", "set", ".", "The", "prefix", "chosen", "for", "each", "namespace", "is", "its", "preferred", "prefix", "if", "it", "s", "not", "None", ".", "If", "the", "preferred", "prefix", "is", "None", "one", "is", "chosen", "from", "the", "set", "of", "registered", "prefixes", ".", "In", "the", "latter", "situation", "if", "no", "prefixes", "are", "registered", "an", "exception", "is", "raised", "." ]

[ "def", "get_uri_schemaloc_map", "(", "self", ")", ":", "mapping", "=", "{", "}", "for", "ni", "in", "six", ".", "itervalues", "(", "self", ".", "__ns_uri_map", ")", ":", "if", "ni", ".", "schema_location", ":", "mapping", "[", "ni", ".", "uri", "]", "=", "ni", ".", "schema_location", "return", "mapping" ]

[ "Constructs", "and", "returns", "a", "map", "from", "namespace", "URI", "to", "schema", "location", "URI", ".", "Namespaces", "without", "schema", "locations", "are", "excluded", "." ]

[ "def", "subset", "(", "self", ",", "ns_uris", ")", ":", "sub_ns", "=", "NamespaceSet", "(", ")", "for", "ns_uri", "in", "ns_uris", ":", "ni", "=", "self", ".", "__lookup_uri", "(", "ns_uri", ")", "new_ni", "=", "copy", ".", "deepcopy", "(", "ni", ")", "# We should be able to reach into details of our own", "# implementation on another obj, right?? This makes the subset", "# operation faster. We can set up the innards directly from a", "# cloned _NamespaceInfo.", "sub_ns", ".", "_NamespaceSet__add_namespaceinfo", "(", "new_ni", ")", "return", "sub_ns" ]

[ "Return", "a", "subset", "of", "this", "NamespaceSet", "containing", "only", "data", "for", "the", "given", "namespaces", "." ]

[ "def", "import_from", "(", "self", ",", "other_ns", ",", "replace", "=", "False", ")", ":", "for", "other_ns_uri", "in", "other_ns", ".", "namespace_uris", ":", "ni", "=", "self", ".", "__ns_uri_map", ".", "get", "(", "other_ns_uri", ")", "if", "ni", "is", "None", ":", "other_ni", "=", "other_ns", ".", "_NamespaceSet__ns_uri_map", "[", "other_ns_uri", "]", "# Gotta make sure that the other set isn't mapping its prefixes", "# incompatibly with respect to this set.", "for", "other_prefix", "in", "other_ni", ".", "prefixes", ":", "self", ".", "__check_prefix_conflict", "(", "other_ns_uri", ",", "other_prefix", ")", "cloned_ni", "=", "copy", ".", "deepcopy", "(", "other_ni", ")", "self", ".", "__add_namespaceinfo", "(", "cloned_ni", ")", "elif", "replace", ":", "other_ni", "=", "other_ns", ".", "_NamespaceSet__ns_uri_map", "[", "other_ns_uri", "]", "for", "other_prefix", "in", "other_ni", ".", "prefixes", ":", "self", ".", "__check_prefix_conflict", "(", "ni", ",", "other_prefix", ")", "cloned_ni", "=", "copy", ".", "deepcopy", "(", "other_ni", ")", "self", ".", "remove_namespace", "(", "other_ns_uri", ")", "self", ".", "__add_namespaceinfo", "(", "cloned_ni", ")", "else", ":", "continue" ]

[ "Imports", "namespaces", "into", "this", "set", "from", "other_ns", "." ]

[ "def", "_get_version", "(", "self", ",", "root", ")", ":", "# Note: STIX and MAEC use a \"version\" attribute. To support CybOX, a", "# subclass will need to combine \"cybox_major_version\",", "# \"cybox_minor_version\", and \"cybox_update_version\".", "version", "=", "self", ".", "get_version", "(", "root", ")", "if", "version", ":", "return", "StrictVersion", "(", "version", ")", "raise", "UnknownVersionError", "(", "\"Unable to determine the version of the input document. No \"", "\"version information found on the root element.\"", ")" ]

[ "Return", "the", "version", "of", "the", "root", "element", "passed", "in", "." ]

[ "def", "_check_version", "(", "self", ",", "root", ")", ":", "version", "=", "self", ".", "_get_version", "(", "root", ")", "supported", "=", "[", "StrictVersion", "(", "x", ")", "for", "x", "in", "self", ".", "supported_versions", "(", "root", ".", "tag", ")", "]", "if", "version", "in", "supported", ":", "return", "error", "=", "\"Document version ({0}) not in supported versions ({1})\"", "raise", "UnsupportedVersionError", "(", "message", "=", "error", ".", "format", "(", "version", ",", "supported", ")", ",", "expected", "=", "supported", ",", "found", "=", "version", ")" ]

[ "Ensure", "the", "root", "element", "is", "a", "supported", "version", "." ]

[ "def", "_check_root_tag", "(", "self", ",", "root", ")", ":", "supported", "=", "self", ".", "supported_tags", "(", ")", "if", "root", ".", "tag", "in", "supported", ":", "return", "error", "=", "\"Document root element ({0}) not one of ({1})\"", "raise", "UnsupportedRootElementError", "(", "message", "=", "error", ".", "format", "(", "root", ".", "tag", ",", "supported", ")", ",", "expected", "=", "supported", ",", "found", "=", "root", ".", "tag", ",", ")" ]

[ "Check", "that", "the", "XML", "element", "tree", "has", "a", "supported", "root", "element", "." ]

[ "def", "parse_xml_to_obj", "(", "self", ",", "xml_file", ",", "check_version", "=", "True", ",", "check_root", "=", "True", ",", "encoding", "=", "None", ")", ":", "root", "=", "get_etree_root", "(", "xml_file", ",", "encoding", "=", "encoding", ")", "if", "check_root", ":", "self", ".", "_check_root_tag", "(", "root", ")", "if", "check_version", ":", "self", ".", "_check_version", "(", "root", ")", "entity_class", "=", "self", ".", "get_entity_class", "(", "root", ".", "tag", ")", "entity_obj", "=", "entity_class", ".", "_binding_class", ".", "factory", "(", ")", "entity_obj", ".", "build", "(", "root", ")", "return", "entity_obj" ]

[ "Creates", "a", "STIX", "binding", "object", "from", "the", "supplied", "xml", "file", "." ]

[ "def", "parse_xml", "(", "self", ",", "xml_file", ",", "check_version", "=", "True", ",", "check_root", "=", "True", ",", "encoding", "=", "None", ")", ":", "xml_etree", "=", "get_etree", "(", "xml_file", ",", "encoding", "=", "encoding", ")", "entity_obj", "=", "self", ".", "parse_xml_to_obj", "(", "xml_file", "=", "xml_etree", ",", "check_version", "=", "check_version", ",", "check_root", "=", "check_root", ")", "xml_root_node", "=", "xml_etree", ".", "getroot", "(", ")", "entity", "=", "self", ".", "get_entity_class", "(", "xml_root_node", ".", "tag", ")", ".", "from_obj", "(", "entity_obj", ")", "# Save the parsed nsmap and schemalocations onto the parsed Entity", "entity", ".", "__input_namespaces__", "=", "dict", "(", "iteritems", "(", "xml_root_node", ".", "nsmap", ")", ")", "with", "ignored", "(", "KeyError", ")", ":", "pairs", "=", "get_schemaloc_pairs", "(", "xml_root_node", ")", "entity", ".", "__input_schemalocations__", "=", "dict", "(", "pairs", ")", "return", "entity" ]

[ "Creates", "a", "python", "-", "stix", "STIXPackage", "object", "from", "the", "supplied", "xml_file", "." ]

[ "def", "get_logo_url", "(", "self", ",", "obj", ")", ":", "if", "current_app", "and", "obj", ".", "logo_url", ":", "return", "u'{site_url}{path}'", ".", "format", "(", "site_url", "=", "current_app", ".", "config", ".", "get", "(", "'THEME_SITEURL'", ")", ",", "path", "=", "obj", ".", "logo_url", ",", ")" ]

[ "Get", "the", "community", "logo", "URL", "." ]

[ "def", "item_links_addition", "(", "self", ",", "data", ")", ":", "links_item_factory", "=", "self", ".", "context", ".", "get", "(", "'links_item_factory'", ",", "default_links_item_factory", ")", "data", "[", "'links'", "]", "=", "links_item_factory", "(", "data", ")", "return", "data" ]

[ "Add", "the", "links", "for", "each", "community", "." ]

[ "def", "envelope", "(", "self", ",", "data", ",", "many", ")", ":", "if", "not", "many", ":", "return", "data", "result", "=", "dict", "(", "hits", "=", "dict", "(", "hits", "=", "data", ",", "total", "=", "self", ".", "context", ".", "get", "(", "'total'", ",", "len", "(", "data", ")", ")", ")", ")", "page", "=", "self", ".", "context", ".", "get", "(", "'page'", ")", "if", "page", ":", "links_pagination_factory", "=", "self", ".", "context", ".", "get", "(", "'links_pagination_factory'", ",", "default_links_pagination_factory", ")", "urlkwargs", "=", "self", ".", "context", ".", "get", "(", "'urlkwargs'", ",", "{", "}", ")", "result", "[", "'links'", "]", "=", "links_pagination_factory", "(", "page", ",", "urlkwargs", ")", "return", "result" ]

[ "Wrap", "result", "in", "envelope", "." ]

[ "def", "parse_datetime", "(", "value", ")", ":", "if", "not", "value", ":", "return", "None", "elif", "isinstance", "(", "value", ",", "datetime", ".", "datetime", ")", ":", "return", "value", "return", "dateutil", ".", "parser", ".", "parse", "(", "value", ")" ]

[ "Attempts", "to", "parse", "value", "into", "an", "instance", "of", "datetime", ".", "datetime", ".", "If", "value", "is", "None", "this", "function", "will", "return", "None", "." ]

[ "def", "parse_date", "(", "value", ")", ":", "if", "not", "value", ":", "return", "None", "if", "isinstance", "(", "value", ",", "datetime", ".", "date", ")", ":", "return", "value", "return", "parse_datetime", "(", "value", ")", ".", "date", "(", ")" ]

[ "Attempts", "to", "parse", "value", "into", "an", "instance", "of", "datetime", ".", "date", ".", "If", "value", "is", "None", "this", "function", "will", "return", "None", "." ]

[ "def", "correct_word", "(", "word_string", ")", ":", "if", "word_string", "is", "None", ":", "return", "\"\"", "elif", "isinstance", "(", "word_string", ",", "str", ")", ":", "return", "max", "(", "find_candidates", "(", "word_string", ")", ",", "key", "=", "find_word_prob", ")", "else", ":", "raise", "InputError", "(", "\"string or none type variable not passed as argument to correct_word\"", ")" ]

[ "Finds", "all", "valid", "one", "and", "two", "letter", "corrections", "for", "word_string", "returning", "the", "word", "with", "the", "highest", "relative", "probability", "as", "type", "str", "." ]

[ "def", "find_candidates", "(", "word_string", ")", ":", "if", "word_string", "is", "None", ":", "return", "{", "}", "elif", "isinstance", "(", "word_string", ",", "str", ")", ":", "return", "(", "validate_words", "(", "[", "word_string", "]", ")", "or", "validate_words", "(", "list", "(", "find_one_letter_edits", "(", "word_string", ")", ")", ")", "or", "validate_words", "(", "list", "(", "find_two_letter_edits", "(", "word_string", ")", ")", ")", "or", "set", "(", "[", "word_string", "]", ")", ")", "else", ":", "raise", "InputError", "(", "\"string or none type variable not passed as argument to find_candidates\"", ")" ]

[ "Finds", "all", "potential", "words", "word_string", "could", "have", "intended", "to", "mean", ".", "If", "a", "word", "is", "not", "incorrectly", "spelled", "it", "will", "return", "this", "word", "first", "else", "if", "will", "look", "for", "one", "letter", "edits", "that", "are", "correct", ".", "If", "there", "are", "no", "valid", "one", "letter", "edits", "it", "will", "perform", "a", "two", "letter", "edit", "search", "." ]

[ "def", "find_word_prob", "(", "word_string", ",", "word_total", "=", "sum", "(", "WORD_DISTRIBUTION", ".", "values", "(", ")", ")", ")", ":", "if", "word_string", "is", "None", ":", "return", "0", "elif", "isinstance", "(", "word_string", ",", "str", ")", ":", "return", "WORD_DISTRIBUTION", "[", "word_string", "]", "/", "word_total", "else", ":", "raise", "InputError", "(", "\"string or none type variable not passed as argument to find_word_prob\"", ")" ]

[ "Finds", "the", "relative", "probability", "of", "the", "word", "appearing", "given", "context", "of", "a", "base", "corpus", ".", "Returns", "this", "probability", "value", "as", "a", "float", "instance", "." ]

[ "def", "validate_words", "(", "word_list", ")", ":", "if", "word_list", "is", "None", ":", "return", "{", "}", "elif", "isinstance", "(", "word_list", ",", "list", ")", ":", "if", "not", "word_list", ":", "return", "{", "}", "else", ":", "return", "set", "(", "word", "for", "word", "in", "word_list", "if", "word", "in", "WORD_DISTRIBUTION", ")", "else", ":", "raise", "InputError", "(", "\"list variable not passed as argument to validate_words\"", ")" ]

[ "Checks", "for", "each", "edited", "word", "in", "word_list", "if", "that", "word", "is", "a", "valid", "english", "word", ".", "abs", "Returns", "all", "validated", "words", "as", "a", "set", "instance", "." ]

[ "def", "search_star", "(", "star", ")", ":", "base_url", "=", "\"http://star-api.herokuapp.com/api/v1/stars/\"", "if", "not", "isinstance", "(", "star", ",", "str", ")", ":", "raise", "ValueError", "(", "\"The star arg you provided is not the type of str\"", ")", "else", ":", "base_url", "+=", "star", "return", "dispatch_http_get", "(", "base_url", ")" ]

[ "It", "is", "also", "possible", "to", "query", "the", "stars", "by", "label", "here", "is", "an", "example", "of", "querying", "for", "the", "star", "labeled", "as", "Sun", "." ]

[ "def", "search_exoplanet", "(", "exoplanet", ")", ":", "base_url", "=", "\"http://star-api.herokuapp.com/api/v1/exo_planets/\"", "if", "not", "isinstance", "(", "exoplanet", ",", "str", ")", ":", "raise", "ValueError", "(", "\"The exoplanet arg you provided is not the type of str\"", ")", "else", ":", "base_url", "+=", "exoplanet", "return", "dispatch_http_get", "(", "base_url", ")" ]

[ "It", "is", "also", "possible", "to", "query", "the", "exoplanets", "by", "label", "here", "is", "an", "example", "of", "querying", "for", "the", "exoplanet", "labeled", "as", "11", "Com" ]

[ "def", "search_local_galaxies", "(", "galaxy", ")", ":", "base_url", "=", "\"http://star-api.herokuapp.com/api/v1/local_groups/\"", "if", "not", "isinstance", "(", "galaxy", ",", "str", ")", ":", "raise", "ValueError", "(", "\"The galaxy arg you provided is not the type of str\"", ")", "else", ":", "base_url", "+=", "galaxy", "return", "dispatch_http_get", "(", "base_url", ")" ]

[ "It", "is", "also", "possible", "to", "query", "the", "local", "galaxies", "by", "label", "here", "is", "an", "example", "of", "querying", "for", "the", "local", "galaxy", "labeled", "IC", "10" ]

[ "def", "search_star_cluster", "(", "cluster", ")", ":", "base_url", "=", "\"http://star-api.herokuapp.com/api/v1/open_cluster/\"", "if", "not", "isinstance", "(", "cluster", ",", "str", ")", ":", "raise", "ValueError", "(", "\"The cluster arg you provided is not the type of str\"", ")", "else", ":", "base_url", "+=", "cluster", "return", "dispatch_http_get", "(", "base_url", ")" ]

[ "It", "is", "also", "possible", "to", "query", "the", "star", "clusters", "by", "label", "here", "is", "an", "example", "of", "querying", "for", "the", "star", "cluster", "labeled", "Berkeley", "59" ]

[ "def", "as_python", "(", "self", ",", "name", ":", "str", ")", "->", "str", ":", "if", "self", ".", "_ruleTokens", ":", "pattern", "=", "\"jsg.JSGPattern(r'{}'.format({}))\"", ".", "format", "(", "self", ".", "_rulePattern", ",", "', '", ".", "join", "(", "[", "'{v}={v}.pattern'", ".", "format", "(", "v", "=", "v", ")", "for", "v", "in", "sorted", "(", "self", ".", "_ruleTokens", ")", "]", ")", ")", "else", ":", "pattern", "=", "\"jsg.JSGPattern(r'{}')\"", ".", "format", "(", "self", ".", "_rulePattern", ")", "base_type", "=", "self", ".", "_jsontype", ".", "signature_type", "(", ")", "if", "self", ".", "_jsontype", "else", "\"jsg.JSGString\"", "return", "python_template", ".", "format", "(", "name", "=", "name", ",", "base_type", "=", "base_type", ",", "pattern", "=", "pattern", ")" ]

[ "Return", "the", "python", "representation" ]

[ "def", "increment_slug", "(", "s", ")", ":", "slug_parts", "=", "s", ".", "split", "(", "'-'", ")", "# advance (or add) the serial counter on the end of this slug", "# noinspection PyBroadException", "try", ":", "# if it's an integer, increment it", "slug_parts", "[", "-", "1", "]", "=", "str", "(", "1", "+", "int", "(", "slug_parts", "[", "-", "1", "]", ")", ")", "except", ":", "# there's no counter! add one now", "slug_parts", ".", "append", "(", "'2'", ")", "return", "'-'", ".", "join", "(", "slug_parts", ")" ]

[ "Generate", "next", "slug", "for", "a", "series", "." ]

[ "def", "underscored2camel_case", "(", "v", ")", ":", "vlist", "=", "v", ".", "split", "(", "'_'", ")", "c", "=", "[", "]", "for", "n", ",", "el", "in", "enumerate", "(", "vlist", ")", ":", "if", "el", ":", "if", "n", "==", "0", ":", "c", ".", "append", "(", "el", ")", "else", ":", "c", ".", "extend", "(", "[", "el", "[", "0", "]", ".", "upper", "(", ")", ",", "el", "[", "1", ":", "]", "]", ")", "return", "''", ".", "join", "(", "c", ")" ]

[ "converts", "ott_id", "to", "ottId", "." ]

[ "def", "unvalidated_parm", "(", "self", ",", "parm", ":", "str", ")", "->", "bool", ":", "return", "parm", ".", "startswith", "(", "\"_\"", ")", "or", "parm", "==", "self", ".", "TYPE", "or", "parm", "in", "self", ".", "IGNORE", "or", "(", "self", ".", "JSON_LD", "and", "parm", ".", "startswith", "(", "'@'", ")", ")" ]

[ "Return", "true", "if", "the", "pair", "name", "should", "be", "ignored" ]

[ "def", "dispatch", "(", "self", ",", "request", ")", ":", "def", "_wrapped", "(", ")", ":", "messages", "=", "self", ".", "_get_request_messages", "(", "request", ")", "results", "=", "[", "self", ".", "_dispatch_and_handle_errors", "(", "message", ")", "for", "message", "in", "messages", "]", "non_notification_results", "=", "[", "x", "for", "x", "in", "results", "if", "x", "is", "not", "None", "]", "if", "len", "(", "non_notification_results", ")", "==", "0", ":", "return", "None", "elif", "len", "(", "messages", ")", "==", "1", ":", "return", "non_notification_results", "[", "0", "]", "else", ":", "return", "non_notification_results", "result", ",", "_", "=", "self", ".", "_handle_exceptions", "(", "_wrapped", ")", "if", "result", "is", "not", "None", ":", "return", "self", ".", "_encode_complete_result", "(", "result", ")" ]

[ "Takes", "a", "request", "and", "dispatches", "its", "data", "to", "a", "jsonrpc", "method", "." ]

[ "def", "register", "(", "self", ",", "name", ",", "method", ",", "method_signature", "=", "None", ")", ":", "if", "inspect", ".", "ismethod", "(", "method", ")", ":", "raise", "Exception", "(", "\"typedjsonrpc does not support making class methods into endpoints\"", ")", "self", ".", "_name_to_method_info", "[", "name", "]", "=", "MethodInfo", "(", "name", ",", "method", ",", "method_signature", ")" ]

[ "Registers", "a", "method", "with", "a", "given", "name", "and", "signature", "." ]

[ "def", "method", "(", "self", ",", "returns", ",", "*", "*", "parameter_types", ")", ":", "@", "wrapt", ".", "decorator", "def", "type_check_wrapper", "(", "method", ",", "instance", ",", "args", ",", "kwargs", ")", ":", "\"\"\"Wraps a method so that it is type-checked.\n\n :param method: The method to wrap\n :type method: (T) -> U\n :return: The result of calling the method with the given parameters\n :rtype: U\n \"\"\"", "if", "instance", "is", "not", "None", ":", "raise", "Exception", "(", "\"Instance shouldn't be set.\"", ")", "parameter_names", "=", "inspect", ".", "getargspec", "(", "method", ")", ".", "args", "# pylint: disable=deprecated-method", "defaults", "=", "inspect", ".", "getargspec", "(", "method", ")", ".", "defaults", "# pylint: disable=deprecated-method", "parameters", "=", "self", ".", "_collect_parameters", "(", "parameter_names", ",", "args", ",", "kwargs", ",", "defaults", ")", "parameter_checker", ".", "check_types", "(", "parameters", ",", "parameter_types", ",", "self", ".", "_strict_floats", ")", "result", "=", "method", "(", "*", "args", ",", "*", "*", "kwargs", ")", "parameter_checker", ".", "check_return_type", "(", "result", ",", "returns", ",", "self", ".", "_strict_floats", ")", "return", "result", "def", "register_method", "(", "method", ")", ":", "\"\"\"Registers a method with its fully qualified name.\n\n :param method: The method to register\n :type method: function\n :return: The original method wrapped into a type-checker\n :rtype: function\n \"\"\"", "parameter_names", "=", "inspect", ".", "getargspec", "(", "method", ")", ".", "args", "# pylint: disable=deprecated-method", "parameter_checker", ".", "check_type_declaration", "(", "parameter_names", ",", "parameter_types", ")", "wrapped_method", "=", "type_check_wrapper", "(", "method", ",", "None", ",", "None", ",", "None", ")", "fully_qualified_name", "=", "\"{}.{}\"", ".", "format", "(", "method", ".", "__module__", ",", "method", ".", "__name__", ")", "self", ".", "register", "(", "fully_qualified_name", ",", "wrapped_method", ",", "MethodSignature", ".", "create", "(", "parameter_names", ",", "parameter_types", ",", "returns", ")", ")", "return", "wrapped_method", "return", "register_method" ]

[ "Syntactic", "sugar", "for", "registering", "a", "method" ]

[ "def", "_collect_parameters", "(", "parameter_names", ",", "args", ",", "kwargs", ",", "defaults", ")", ":", "parameters", "=", "{", "}", "if", "defaults", "is", "not", "None", ":", "zipped_defaults", "=", "zip", "(", "reversed", "(", "parameter_names", ")", ",", "reversed", "(", "defaults", ")", ")", "for", "name", ",", "default", "in", "zipped_defaults", ":", "parameters", "[", "name", "]", "=", "default", "for", "name", ",", "value", "in", "zip", "(", "parameter_names", ",", "args", ")", ":", "parameters", "[", "name", "]", "=", "value", "for", "name", ",", "value", "in", "kwargs", ".", "items", "(", ")", ":", "parameters", "[", "name", "]", "=", "value", "return", "parameters" ]

[ "Creates", "a", "dictionary", "mapping", "parameters", "names", "to", "their", "values", "in", "the", "method", "call", "." ]

[ "def", "_get_request_messages", "(", "self", ",", "request", ")", ":", "data", "=", "request", ".", "get_data", "(", "as_text", "=", "True", ")", "try", ":", "msg", "=", "self", ".", "json_decoder", ".", "decode", "(", "data", ")", "except", "Exception", ":", "raise", "ParseError", "(", "\"Could not parse request data '{}'\"", ".", "format", "(", "data", ")", ")", "if", "isinstance", "(", "msg", ",", "list", ")", ":", "return", "msg", "else", ":", "return", "[", "msg", "]" ]

[ "Parses", "the", "request", "as", "a", "json", "message", "." ]

[ "def", "_check_request", "(", "self", ",", "msg", ")", ":", "if", "\"jsonrpc\"", "not", "in", "msg", ":", "raise", "InvalidRequestError", "(", "\"'\\\"jsonrpc\\\": \\\"2.0\\\"' must be included.\"", ")", "if", "msg", "[", "\"jsonrpc\"", "]", "!=", "\"2.0\"", ":", "raise", "InvalidRequestError", "(", "\"'jsonrpc' must be exactly the string '2.0', but it was '{}'.\"", ".", "format", "(", "msg", "[", "\"jsonrpc\"", "]", ")", ")", "if", "\"method\"", "not", "in", "msg", ":", "raise", "InvalidRequestError", "(", "\"No method specified.\"", ")", "if", "\"id\"", "in", "msg", ":", "if", "msg", "[", "\"id\"", "]", "is", "None", ":", "raise", "InvalidRequestError", "(", "\"typedjsonrpc does not allow id to be None.\"", ")", "if", "isinstance", "(", "msg", "[", "\"id\"", "]", ",", "float", ")", ":", "raise", "InvalidRequestError", "(", "\"typedjsonrpc does not support float ids.\"", ")", "if", "not", "isinstance", "(", "msg", "[", "\"id\"", "]", ",", "(", "six", ".", "string_types", ",", "six", ".", "integer_types", ")", ")", ":", "raise", "InvalidRequestError", "(", "\"id must be a string or integer; '{}' is of type {}.\"", ".", "format", "(", "msg", "[", "\"id\"", "]", ",", "type", "(", "msg", "[", "\"id\"", "]", ")", ")", ")", "if", "msg", "[", "\"method\"", "]", "not", "in", "self", ".", "_name_to_method_info", ":", "raise", "MethodNotFoundError", "(", "\"Could not find method '{}'.\"", ".", "format", "(", "msg", "[", "\"method\"", "]", ")", ")" ]

[ "Checks", "that", "the", "request", "json", "is", "well", "-", "formed", "." ]

[ "def", "render_template_to_string", "(", "input", ",", "_from_string", "=", "False", ",", "*", "*", "context", ")", ":", "if", "_from_string", ":", "template", "=", "current_app", ".", "jinja_env", ".", "from_string", "(", "input", ")", "else", ":", "template", "=", "current_app", ".", "jinja_env", ".", "get_or_select_template", "(", "input", ")", "return", "template", ".", "render", "(", "context", ")" ]

[ "Render", "a", "template", "from", "the", "template", "folder", "with", "the", "given", "context", "." ]

[ "def", "save_and_validate_logo", "(", "logo_stream", ",", "logo_filename", ",", "community_id", ")", ":", "cfg", "=", "current_app", ".", "config", "logos_bucket_id", "=", "cfg", "[", "'COMMUNITIES_BUCKET_UUID'", "]", "logo_max_size", "=", "cfg", "[", "'COMMUNITIES_LOGO_MAX_SIZE'", "]", "logos_bucket", "=", "Bucket", ".", "query", ".", "get", "(", "logos_bucket_id", ")", "ext", "=", "os", ".", "path", ".", "splitext", "(", "logo_filename", ")", "[", "1", "]", "ext", "=", "ext", "[", "1", ":", "]", "if", "ext", ".", "startswith", "(", "'.'", ")", "else", "ext", "logo_stream", ".", "seek", "(", "SEEK_SET", ",", "SEEK_END", ")", "# Seek from beginning to end", "logo_size", "=", "logo_stream", ".", "tell", "(", ")", "if", "logo_size", ">", "logo_max_size", ":", "return", "None", "if", "ext", "in", "cfg", "[", "'COMMUNITIES_LOGO_EXTENSIONS'", "]", ":", "key", "=", "\"{0}/logo.{1}\"", ".", "format", "(", "community_id", ",", "ext", ")", "logo_stream", ".", "seek", "(", "0", ")", "# Rewind the stream to the beginning", "ObjectVersion", ".", "create", "(", "logos_bucket", ",", "key", ",", "stream", "=", "logo_stream", ",", "size", "=", "logo_size", ")", "return", "ext", "else", ":", "return", "None" ]

[ "Validate", "if", "communities", "logo", "is", "in", "limit", "size", "and", "save", "it", "." ]

[ "def", "initialize_communities_bucket", "(", ")", ":", "bucket_id", "=", "UUID", "(", "current_app", ".", "config", "[", "'COMMUNITIES_BUCKET_UUID'", "]", ")", "if", "Bucket", ".", "query", ".", "get", "(", "bucket_id", ")", ":", "raise", "FilesException", "(", "\"Bucket with UUID {} already exists.\"", ".", "format", "(", "bucket_id", ")", ")", "else", ":", "storage_class", "=", "current_app", ".", "config", "[", "'FILES_REST_DEFAULT_STORAGE_CLASS'", "]", "location", "=", "Location", ".", "get_default", "(", ")", "bucket", "=", "Bucket", "(", "id", "=", "bucket_id", ",", "location", "=", "location", ",", "default_storage_class", "=", "storage_class", ")", "db", ".", "session", ".", "add", "(", "bucket", ")", "db", ".", "session", ".", "commit", "(", ")" ]

[ "Initialize", "the", "communities", "file", "bucket", "." ]

[ "def", "format_request_email_templ", "(", "increq", ",", "template", ",", "*", "*", "ctx", ")", ":", "# Add minimal information to the contex (without overwriting).", "curate_link", "=", "'{site_url}/communities/{id}/curate/'", ".", "format", "(", "site_url", "=", "current_app", ".", "config", "[", "'THEME_SITEURL'", "]", ",", "id", "=", "increq", ".", "community", ".", "id", ")", "min_ctx", "=", "dict", "(", "record", "=", "Record", ".", "get_record", "(", "increq", ".", "record", ".", "id", ")", ",", "requester", "=", "increq", ".", "user", ",", "community", "=", "increq", ".", "community", ",", "curate_link", "=", "curate_link", ",", ")", "for", "k", ",", "v", "in", "min_ctx", ".", "items", "(", ")", ":", "if", "k", "not", "in", "ctx", ":", "ctx", "[", "k", "]", "=", "v", "msg_element", "=", "render_template_to_string", "(", "template", ",", "*", "*", "ctx", ")", "return", "msg_element" ]

[ "Format", "the", "email", "message", "element", "for", "inclusion", "request", "notification", "." ]

[ "def", "format_request_email_title", "(", "increq", ",", "*", "*", "ctx", ")", ":", "template", "=", "current_app", ".", "config", "[", "\"COMMUNITIES_REQUEST_EMAIL_TITLE_TEMPLATE\"", "]", ",", "return", "format_request_email_templ", "(", "increq", ",", "template", ",", "*", "*", "ctx", ")" ]

[ "Format", "the", "email", "message", "title", "for", "inclusion", "request", "notification", "." ]

[ "def", "format_request_email_body", "(", "increq", ",", "*", "*", "ctx", ")", ":", "template", "=", "current_app", ".", "config", "[", "\"COMMUNITIES_REQUEST_EMAIL_BODY_TEMPLATE\"", "]", ",", "return", "format_request_email_templ", "(", "increq", ",", "template", ",", "*", "*", "ctx", ")" ]

[ "Format", "the", "email", "message", "body", "for", "inclusion", "request", "notification", "." ]

[ "def", "send_community_request_email", "(", "increq", ")", ":", "from", "flask_mail", "import", "Message", "from", "invenio_mail", ".", "tasks", "import", "send_email", "msg_body", "=", "format_request_email_body", "(", "increq", ")", "msg_title", "=", "format_request_email_title", "(", "increq", ")", "sender", "=", "current_app", ".", "config", "[", "'COMMUNITIES_REQUEST_EMAIL_SENDER'", "]", "msg", "=", "Message", "(", "msg_title", ",", "sender", "=", "sender", ",", "recipients", "=", "[", "increq", ".", "community", ".", "owner", ".", "email", ",", "]", ",", "body", "=", "msg_body", ")", "send_email", ".", "delay", "(", "msg", ".", "__dict__", ")" ]

[ "Signal", "for", "sending", "emails", "after", "community", "inclusion", "request", "." ]

[ "def", "modifydocs", "(", "a", ",", "b", ",", "desc", "=", "''", ")", ":", "newdoc", "=", "a", ".", "func_doc", ".", "replace", "(", "'\\t\\t'", ",", "'\\t'", ")", "newdoc", "+=", "\"Documentation from \"", "+", "desc", "+", "\":\\n\"", "+", "b", ".", "func_doc", "return", "newdoc" ]

[ "Convenience", "function", "for", "writing", "documentation", "." ]

[ "def", "tab_join", "(", "ToMerge", ",", "keycols", "=", "None", ",", "nullvals", "=", "None", ",", "renamer", "=", "None", ",", "returnrenaming", "=", "False", ",", "Names", "=", "None", ")", ":", "[", "Result", ",", "Renaming", "]", "=", "spreadsheet", ".", "join", "(", "ToMerge", ",", "keycols", "=", "keycols", ",", "nullvals", "=", "nullvals", ",", "renamer", "=", "renamer", ",", "returnrenaming", "=", "True", ",", "Names", "=", "Names", ")", "if", "isinstance", "(", "ToMerge", ",", "dict", ")", ":", "Names", "=", "ToMerge", ".", "keys", "(", ")", "else", ":", "Names", "=", "range", "(", "len", "(", "ToMerge", ")", ")", "Colorings", "=", "dict", "(", "[", "(", "k", ",", "ToMerge", "[", "k", "]", ".", "coloring", ")", "if", "'coloring'", "in", "dir", "(", "ToMerge", "[", "k", "]", ")", "else", "{", "}", "for", "k", "in", "Names", "]", ")", "for", "k", "in", "Names", ":", "if", "k", "in", "Renaming", ".", "keys", "(", ")", ":", "l", "=", "ToMerge", "[", "k", "]", "Colorings", "[", "k", "]", "=", "dict", "(", "[", "(", "g", ",", "[", "n", "if", "not", "n", "in", "Renaming", "[", "k", "]", ".", "keys", "(", ")", "else", "Renaming", "[", "k", "]", "[", "n", "]", "for", "n", "in", "l", ".", "coloring", "[", "g", "]", "]", ")", "for", "g", "in", "Colorings", "[", "k", "]", ".", "keys", "(", ")", "]", ")", "Coloring", "=", "{", "}", "for", "k", "in", "Colorings", ".", "keys", "(", ")", ":", "for", "j", "in", "Colorings", "[", "k", "]", ".", "keys", "(", ")", ":", "if", "j", "in", "Coloring", ".", "keys", "(", ")", ":", "Coloring", "[", "j", "]", "=", "utils", ".", "uniqify", "(", "Coloring", "[", "j", "]", "+", "Colorings", "[", "k", "]", "[", "j", "]", ")", "else", ":", "Coloring", "[", "j", "]", "=", "utils", ".", "uniqify", "(", "Colorings", "[", "k", "]", "[", "j", "]", ")", "Result", "=", "Result", ".", "view", "(", "tabarray", ")", "Result", ".", "coloring", "=", "Coloring", "if", "returnrenaming", ":", "return", "[", "Result", ",", "Renaming", "]", "else", ":", "return", "Result" ]

[ "Database", "-", "join", "for", "tabular", "arrays", "." ]

[ "def", "extract", "(", "self", ")", ":", "return", "np", ".", "vstack", "(", "[", "self", "[", "r", "]", "for", "r", "in", "self", ".", "dtype", ".", "names", "]", ")", ".", "T", ".", "squeeze", "(", ")" ]

[ "Creates", "a", "copy", "of", "this", "tabarray", "in", "the", "form", "of", "a", "numpy", "ndarray", "." ]

[ "def", "addrecords", "(", "self", ",", "new", ")", ":", "data", "=", "spreadsheet", ".", "addrecords", "(", "self", ",", "new", ")", "data", "=", "data", ".", "view", "(", "tabarray", ")", "data", ".", "coloring", "=", "self", ".", "coloring", "return", "data" ]

[ "Append", "one", "or", "more", "records", "to", "the", "end", "of", "the", "array", "." ]

[ "def", "addcols", "(", "self", ",", "cols", ",", "names", "=", "None", ")", ":", "data", "=", "spreadsheet", ".", "addcols", "(", "self", ",", "cols", ",", "names", ")", "data", "=", "data", ".", "view", "(", "tabarray", ")", "data", ".", "coloring", "=", "self", ".", "coloring", "return", "data" ]

[ "Add", "one", "or", "more", "new", "columns", "." ]

[ "def", "renamecol", "(", "self", ",", "old", ",", "new", ")", ":", "spreadsheet", ".", "renamecol", "(", "self", ",", "old", ",", "new", ")", "for", "x", "in", "self", ".", "coloring", ".", "keys", "(", ")", ":", "if", "old", "in", "self", ".", "coloring", "[", "x", "]", ":", "ind", "=", "self", ".", "coloring", "[", "x", "]", ".", "index", "(", "old", ")", "self", ".", "coloring", "[", "x", "]", "[", "ind", "]", "=", "new" ]

[ "Rename", "column", "or", "color", "in", "-", "place", "." ]

[ "def", "colstack", "(", "self", ",", "new", ",", "mode", "=", "'abort'", ")", ":", "if", "isinstance", "(", "new", ",", "list", ")", ":", "return", "tab_colstack", "(", "[", "self", "]", "+", "new", ",", "mode", ")", "else", ":", "return", "tab_colstack", "(", "[", "self", ",", "new", "]", ",", "mode", ")" ]

[ "Horizontal", "stacking", "for", "tabarrays", "." ]

[ "def", "rowstack", "(", "self", ",", "new", ",", "mode", "=", "'nulls'", ")", ":", "if", "isinstance", "(", "new", ",", "list", ")", ":", "return", "tab_rowstack", "(", "[", "self", "]", "+", "new", ",", "mode", ")", "else", ":", "return", "tab_rowstack", "(", "[", "self", ",", "new", "]", ",", "mode", ")" ]

[ "Vertical", "stacking", "for", "tabarrays", "." ]

[ "def", "aggregate", "(", "self", ",", "On", "=", "None", ",", "AggFuncDict", "=", "None", ",", "AggFunc", "=", "None", ",", "AggList", "=", "None", ",", "returnsort", "=", "False", ",", "KeepOthers", "=", "True", ",", "keyfuncdict", "=", "None", ")", ":", "if", "returnsort", ":", "[", "data", ",", "s", "]", "=", "spreadsheet", ".", "aggregate", "(", "X", "=", "self", ",", "On", "=", "On", ",", "AggFuncDict", "=", "AggFuncDict", ",", "AggFunc", "=", "AggFunc", ",", "AggList", "=", "AggList", ",", "returnsort", "=", "returnsort", ",", "keyfuncdict", "=", "keyfuncdict", ")", "else", ":", "data", "=", "spreadsheet", ".", "aggregate", "(", "X", "=", "self", ",", "On", "=", "On", ",", "AggFuncDict", "=", "AggFuncDict", ",", "AggFunc", "=", "AggFunc", ",", "AggList", "=", "AggList", ",", "returnsort", "=", "returnsort", ",", "KeepOthers", "=", "KeepOthers", ",", "keyfuncdict", "=", "keyfuncdict", ")", "data", "=", "data", ".", "view", "(", "tabarray", ")", "data", ".", "coloring", "=", "self", ".", "coloring", "if", "returnsort", ":", "return", "[", "data", ",", "s", "]", "else", ":", "return", "data" ]

[ "Aggregate", "a", "tabarray", "on", "columns", "for", "given", "functions", "." ]

[ "def", "aggregate_in", "(", "self", ",", "On", "=", "None", ",", "AggFuncDict", "=", "None", ",", "AggFunc", "=", "None", ",", "AggList", "=", "None", ",", "interspersed", "=", "True", ")", ":", "data", "=", "spreadsheet", ".", "aggregate_in", "(", "Data", "=", "self", ",", "On", "=", "On", ",", "AggFuncDict", "=", "AggFuncDict", ",", "AggFunc", "=", "AggFunc", ",", "AggList", "=", "AggList", ",", "interspersed", "=", "interspersed", ")", "data", "=", "data", ".", "view", "(", "tabarray", ")", "data", ".", "view", "=", "self", ".", "coloring", "return", "data" ]

[ "Aggregate", "a", "tabarray", "and", "include", "original", "data", "in", "the", "result", "." ]

[ "def", "pivot", "(", "self", ",", "a", ",", "b", ",", "Keep", "=", "None", ",", "NullVals", "=", "None", ",", "order", "=", "None", ",", "prefix", "=", "'_'", ")", ":", "[", "data", ",", "coloring", "]", "=", "spreadsheet", ".", "pivot", "(", "X", "=", "self", ",", "a", "=", "a", ",", "b", "=", "b", ",", "Keep", "=", "Keep", ",", "NullVals", "=", "NullVals", ",", "order", "=", "order", ",", "prefix", "=", "prefix", ")", "data", "=", "data", ".", "view", "(", "tabarray", ")", "data", ".", "coloring", "=", "coloring", "return", "data" ]

[ "Pivot", "with", "a", "as", "the", "row", "axis", "and", "b", "values", "as", "the", "column", "axis", "." ]

[ "def", "join", "(", "self", ",", "ToMerge", ",", "keycols", "=", "None", ",", "nullvals", "=", "None", ",", "renamer", "=", "None", ",", "returnrenaming", "=", "False", ",", "selfname", "=", "None", ",", "Names", "=", "None", ")", ":", "if", "isinstance", "(", "ToMerge", ",", "np", ".", "ndarray", ")", ":", "ToMerge", "=", "[", "ToMerge", "]", "if", "isinstance", "(", "ToMerge", ",", "dict", ")", ":", "assert", "selfname", "not", "in", "ToMerge", ".", "keys", "(", ")", ",", "(", "'Can\\'t use \"'", ",", "selfname", "+", "'\" for name of one of the things to '", "'merge, since it is the same name as the self object.'", ")", "if", "selfname", "==", "None", ":", "try", ":", "selfname", "=", "self", ".", "name", "except", "AttributeError", ":", "selfname", "=", "'self'", "ToMerge", ".", "update", "(", "{", "selfname", ":", "self", "}", ")", "else", ":", "ToMerge", "=", "[", "self", "]", "+", "ToMerge", "return", "tab_join", "(", "ToMerge", ",", "keycols", "=", "keycols", ",", "nullvals", "=", "nullvals", ",", "renamer", "=", "renamer", ",", "returnrenaming", "=", "returnrenaming", ",", "Names", "=", "Names", ")" ]

[ "Wrapper", "for", "spreadsheet", ".", "join", "but", "handles", "coloring", "attributes", "." ]

[ "def", "argsort", "(", "self", ",", "axis", "=", "-", "1", ",", "kind", "=", "'quicksort'", ",", "order", "=", "None", ")", ":", "index_array", "=", "np", ".", "core", ".", "fromnumeric", ".", "_wrapit", "(", "self", ",", "'argsort'", ",", "axis", ",", "kind", ",", "order", ")", "index_array", "=", "index_array", ".", "view", "(", "np", ".", "ndarray", ")", "return", "index_array" ]

[ "Returns", "the", "indices", "that", "would", "sort", "an", "array", "." ]

[ "def", "matches", "(", "self", ",", "txt", ":", "str", ")", "->", "bool", ":", "# rval = ref.getText()[1:-1].encode('utf-8').decode('unicode-escape')", "if", "r'\\\\u'", "in", "self", ".", "pattern_re", ".", "pattern", ":", "txt", "=", "txt", ".", "encode", "(", "'utf-8'", ")", ".", "decode", "(", "'unicode-escape'", ")", "match", "=", "self", ".", "pattern_re", ".", "match", "(", "txt", ")", "return", "match", "is", "not", "None", "and", "match", ".", "end", "(", ")", "==", "len", "(", "txt", ")" ]

[ "Determine", "whether", "txt", "matches", "pattern" ]

[ "def", "Point2HexColor", "(", "a", ",", "lfrac", ",", "tfrac", ")", ":", "[", "H", ",", "S", ",", "V", "]", "=", "[", "math", ".", "floor", "(", "360", "*", "a", ")", ",", "lfrac", ",", "tfrac", "]", "RGB", "=", "hsvToRGB", "(", "H", ",", "S", ",", "V", ")", "H", "=", "[", "hex", "(", "int", "(", "math", ".", "floor", "(", "255", "*", "x", ")", ")", ")", "for", "x", "in", "RGB", "]", "HEX", "=", "[", "a", "[", "a", ".", "find", "(", "'x'", ")", "+", "1", ":", "]", "for", "a", "in", "H", "]", "HEX", "=", "[", "'0'", "+", "h", "if", "len", "(", "h", ")", "==", "1", "else", "h", "for", "h", "in", "HEX", "]", "return", "'#'", "+", "''", ".", "join", "(", "HEX", ")" ]

[ "Return", "web", "-", "safe", "hex", "triplets", "." ]

[ "def", "warn_from_util_logger", "(", "msg", ")", ":", "global", "_LOG", "# This check is necessary to avoid infinite recursion when called from get_config, because", "# the _read_logging_conf can require reading a conf file.", "if", "_LOG", "is", "None", "and", "_LOGGING_CONF", "is", "None", ":", "sys", ".", "stderr", ".", "write", "(", "'WARNING: (from peyotl before logging is configured) {}\\n'", ".", "format", "(", "msg", ")", ")", "return", "if", "_LOG", "is", "None", ":", "_LOG", "=", "get_logger", "(", "\"peyotl.utility\"", ")", "_LOG", ".", "warn", "(", "msg", ")" ]

[ "Only", "to", "be", "used", "in", "this", "file", "and", "peyotl", ".", "utility", ".", "get_config" ]

[ "def", "state_delta", "(", "self", ",", "selector", "=", "'all'", ",", "power", "=", "None", ",", "duration", "=", "1.0", ",", "infrared", "=", "None", ",", "hue", "=", "None", ",", "saturation", "=", "None", ",", "brightness", "=", "None", ",", "kelvin", "=", "None", ")", ":", "argument_tuples", "=", "[", "(", "\"power\"", ",", "power", ")", ",", "(", "\"duration\"", ",", "duration", ")", ",", "(", "\"infrared\"", ",", "infrared", ")", ",", "(", "\"hue\"", ",", "hue", ")", ",", "(", "\"saturation\"", ",", "saturation", ")", ",", "(", "\"brightness\"", ",", "brightness", ")", ",", "(", "\"kelvin\"", ",", "kelvin", ")", "]", "return", "self", ".", "client", ".", "perform_request", "(", "method", "=", "'post'", ",", "endpoint", "=", "'lights/{}/state/delta'", ",", "endpoint_args", "=", "[", "selector", "]", ",", "argument_tuples", "=", "argument_tuples", ")" ]

[ "Given", "a", "state", "delta", "apply", "the", "modifications", "to", "lights", "state", "over", "a", "given", "period", "of", "time", "." ]

[ "def", "breathe_lights", "(", "self", ",", "color", ",", "selector", "=", "'all'", ",", "from_color", "=", "None", ",", "period", "=", "1.0", ",", "cycles", "=", "1.0", ",", "persist", "=", "False", ",", "power_on", "=", "True", ",", "peak", "=", "0.5", ")", ":", "argument_tuples", "=", "[", "(", "\"color\"", ",", "color", ")", ",", "(", "\"from_color\"", ",", "from_color", ")", ",", "(", "\"period\"", ",", "period", ")", ",", "(", "\"cycles\"", ",", "cycles", ")", ",", "(", "\"persist\"", ",", "persist", ")", ",", "(", "\"power_on\"", ",", "power_on", ")", ",", "(", "\"peak\"", ",", "peak", ")", ",", "]", "return", "self", ".", "client", ".", "perform_request", "(", "method", "=", "'post'", ",", "endpoint", "=", "'lights/{}/effects/breathe'", ",", "endpoint_args", "=", "[", "selector", "]", ",", "argument_tuples", "=", "argument_tuples", ")" ]

[ "Perform", "breathe", "effect", "on", "lights", "." ]

[ "def", "cycle_lights", "(", "self", ",", "states", ",", "defaults", ",", "direction", "=", "'forward'", ",", "selector", "=", "'all'", ")", ":", "argument_tuples", "=", "[", "(", "\"states\"", ",", "states", ")", ",", "(", "\"defaults\"", ",", "defaults", ")", ",", "(", "\"direction\"", ",", "direction", ")", "]", "return", "self", ".", "client", ".", "perform_request", "(", "method", "=", "'post'", ",", "endpoint", "=", "'lights/{}/cycle'", ",", "endpoint_args", "=", "[", "selector", "]", ",", "argument_tuples", "=", "argument_tuples", ",", "json_body", "=", "True", ")" ]

[ "Cycle", "through", "list", "of", "effects", "." ]

[ "def", "activate_scene", "(", "self", ",", "scene_uuid", ",", "duration", "=", "1.0", ")", ":", "argument_tuples", "=", "[", "(", "\"duration\"", ",", "duration", ")", ",", "]", "return", "self", ".", "client", ".", "perform_request", "(", "method", "=", "'put'", ",", "endpoint", "=", "'scenes/scene_id:{}/activate'", ",", "endpoint_args", "=", "[", "scene_uuid", "]", ",", "argument_tuples", "=", "argument_tuples", ")" ]

[ "Activate", "a", "scene", "." ]

[ "def", "count_num_trees", "(", "nexson", ",", "nexson_version", "=", "None", ")", ":", "if", "nexson_version", "is", "None", ":", "nexson_version", "=", "detect_nexson_version", "(", "nexson", ")", "nex", "=", "get_nexml_el", "(", "nexson", ")", "num_trees_by_group", "=", "[", "]", "if", "_is_by_id_hbf", "(", "nexson_version", ")", ":", "for", "tree_group", "in", "nex", ".", "get", "(", "'treesById'", ",", "{", "}", ")", ".", "values", "(", ")", ":", "nt", "=", "len", "(", "tree_group", ".", "get", "(", "'treeById'", ",", "{", "}", ")", ")", "num_trees_by_group", ".", "append", "(", "nt", ")", "else", ":", "trees_group", "=", "nex", ".", "get", "(", "'trees'", ",", "[", "]", ")", "if", "isinstance", "(", "trees_group", ",", "dict", ")", ":", "trees_group", "=", "[", "trees_group", "]", "for", "tree_group", "in", "trees_group", ":", "t", "=", "tree_group", ".", "get", "(", "'tree'", ")", "if", "isinstance", "(", "t", ",", "list", ")", ":", "nt", "=", "len", "(", "t", ")", "else", ":", "nt", "=", "1", "num_trees_by_group", ".", "append", "(", "nt", ")", "return", "sum", "(", "num_trees_by_group", ")" ]

[ "Returns", "the", "number", "of", "trees", "summed", "across", "all", "tree", "groups", "." ]

[ "def", "TreeCollectionStore", "(", "repos_dict", "=", "None", ",", "repos_par", "=", "None", ",", "with_caching", "=", "True", ",", "assumed_doc_version", "=", "None", ",", "git_ssh", "=", "None", ",", "pkey", "=", "None", ",", "git_action_class", "=", "TreeCollectionsGitAction", ",", "mirror_info", "=", "None", ",", "infrastructure_commit_author", "=", "'OpenTree API <[email protected]>'", ")", ":", "global", "_THE_TREE_COLLECTION_STORE", "if", "_THE_TREE_COLLECTION_STORE", "is", "None", ":", "_THE_TREE_COLLECTION_STORE", "=", "_TreeCollectionStore", "(", "repos_dict", "=", "repos_dict", ",", "repos_par", "=", "repos_par", ",", "with_caching", "=", "with_caching", ",", "assumed_doc_version", "=", "assumed_doc_version", ",", "git_ssh", "=", "git_ssh", ",", "pkey", "=", "pkey", ",", "git_action_class", "=", "git_action_class", ",", "mirror_info", "=", "mirror_info", ",", "infrastructure_commit_author", "=", "infrastructure_commit_author", ")", "return", "_THE_TREE_COLLECTION_STORE" ]

[ "Factory", "function", "for", "a", "_TreeCollectionStore", "object", "." ]

[ "def", "_slugify_internal_collection_name", "(", "self", ",", "json_repr", ")", ":", "collection", "=", "self", ".", "_coerce_json_to_collection", "(", "json_repr", ")", "if", "collection", "is", "None", ":", "return", "None", "internal_name", "=", "collection", "[", "'name'", "]", "return", "slugify", "(", "internal_name", ")" ]

[ "Parse", "the", "JSON", "find", "its", "name", "return", "a", "slug", "of", "its", "name" ]

[ "def", "discover_roku", "(", ")", ":", "print", "(", "\"Searching for Roku devices within LAN ...\"", ")", "rokus", "=", "Roku", ".", "discover", "(", ")", "if", "not", "rokus", ":", "print", "(", "\"Unable to discover Roku devices. \"", "+", "\"Try again, or manually specify the IP address with \"", "+", "\"\\'roku <ipaddr>\\' (e.g. roku 192.168.1.130)\"", ")", "return", "None", "print", "(", "\"Found the following Roku devices:\"", ")", "for", "i", ",", "r", "in", "enumerate", "(", "rokus", ")", ":", "# dinfo = ' '.join(re.split(', |: ', str(r.device_info))[1:3])", "dinfo", "=", "''", "print", "(", "\"[\"", "+", "str", "(", "i", "+", "1", ")", "+", "\"] \"", "+", "str", "(", "r", ".", "host", ")", "+", "\":\"", "+", "str", "(", "r", ".", "port", ")", "+", "' ('", "+", "dinfo", "+", "')'", ")", "print", "(", "\"\"", ")", "if", "len", "(", "rokus", ")", "==", "1", ":", "print", "(", "\"Selecting Roku 1 by default\"", ")", "return", "rokus", "[", "0", "]", "else", ":", "print", "(", "\"Multiple Rokus found. Select the index of the Roku to control:\"", ")", "while", "True", ":", "try", ":", "query", "=", "\"Select (1 to \"", "+", "str", "(", "len", "(", "rokus", ")", ")", "+", "\") > \"", "sel", "=", "int", "(", "input", "(", "query", ")", ")", "-", "1", "if", "sel", ">=", "len", "(", "rokus", ")", ":", "raise", "ValueError", "else", ":", "break", "except", "ValueError", ":", "print", "(", "\"Invalid selection\"", ")", "return", "rokus", "[", "sel", "]" ]

[ "Search", "LAN", "for", "available", "Roku", "devices", ".", "Returns", "a", "Roku", "object", "." ]

[ "def", "ot_tnrs_match_names", "(", "name_list", ",", "context_name", "=", "None", ",", "do_approximate_matching", "=", "True", ",", "include_dubious", "=", "False", ",", "include_deprecated", "=", "True", ",", "tnrs_wrapper", "=", "None", ")", ":", "if", "tnrs_wrapper", "is", "None", ":", "from", "peyotl", ".", "sugar", "import", "tnrs", "tnrs_wrapper", "=", "tnrs", "match_obj", "=", "tnrs_wrapper", ".", "match_names", "(", "name_list", ",", "context_name", "=", "context_name", ",", "do_approximate_matching", "=", "do_approximate_matching", ",", "include_deprecated", "=", "include_deprecated", ",", "include_dubious", "=", "include_dubious", ",", "wrap_response", "=", "True", ")", "return", "match_obj" ]

[ "Uses", "a", "peyotl", "wrapper", "around", "an", "Open", "Tree", "web", "service", "to", "get", "a", "list", "of", "OTT", "IDs", "matching", "the", "name_list", ".", "The", "tnrs_wrapper", "can", "be", "None", "(", "in", "which", "case", "the", "default", "wrapper", "from", "peyotl", ".", "sugar", "will", "be", "used", ".", "All", "other", "arguments", "correspond", "to", "the", "arguments", "of", "the", "web", "-", "service", "call", ".", "A", "ValueError", "will", "be", "raised", "if", "the", "context_name", "does", "not", "match", "one", "of", "the", "valid", "names", "for", "a", "taxonomic", "context", ".", "This", "uses", "the", "wrap_response", "option", "to", "create", "and", "return", "a", "TNRSRespose", "object", "around", "the", "response", "." ]

[ "def", "_objectify", "(", "field", ",", "value", ",", "ns_info", ")", ":", "if", "(", "getattr", "(", "field", ".", "type_", ",", "\"_treat_none_as_empty_list\"", ",", "False", ")", "and", "value", "is", "None", ")", ":", "return", "[", "]", "if", "value", "is", "None", ":", "return", "None", "elif", "field", ".", "type_", ":", "return", "value", ".", "to_obj", "(", "ns_info", "=", "ns_info", ")", "return", "field", ".", "binding_value", "(", "value", ")" ]

[ "Make", "value", "suitable", "for", "a", "binding", "object", "." ]

[ "def", "_dictify", "(", "field", ",", "value", ")", ":", "if", "value", "is", "None", ":", "return", "None", "elif", "field", ".", "type_", ":", "return", "value", ".", "to_dict", "(", ")", "return", "field", ".", "dict_value", "(", "value", ")" ]

[ "Make", "value", "suitable", "for", "a", "dictionary", "." ]

[ "def", "from_dict", "(", "cls", ",", "cls_dict", ",", "fallback_xsi_type", "=", "None", ")", ":", "if", "not", "cls_dict", ":", "return", "None", "if", "isinstance", "(", "cls_dict", ",", "six", ".", "string_types", ")", ":", "if", "not", "getattr", "(", "cls", ",", "\"_convert_strings\"", ",", "False", ")", ":", "return", "cls_dict", "try", ":", "typekey", "=", "cls", ".", "dictkey", "(", "cls_dict", ")", "except", "TypeError", ":", "typekey", "=", "fallback_xsi_type", "klass", "=", "cls", ".", "entity_class", "(", "typekey", ")", "return", "klass", ".", "from_dict", "(", "cls_dict", ")" ]

[ "Parse", "the", "dictionary", "and", "return", "an", "Entity", "instance", "." ]

[ "def", "from_obj", "(", "cls", ",", "cls_obj", ")", ":", "if", "not", "cls_obj", ":", "return", "None", "typekey", "=", "cls", ".", "objkey", "(", "cls_obj", ")", "klass", "=", "cls", ".", "entity_class", "(", "typekey", ")", "return", "klass", ".", "from_obj", "(", "cls_obj", ")" ]

[ "Parse", "the", "generateDS", "object", "and", "return", "an", "Entity", "instance", "." ]

[ "def", "typed_fields", "(", "cls", ")", ":", "# Checking cls._typed_fields could return a superclass _typed_fields", "# value. So we check our class __dict__ which does not include", "# inherited attributes.", "klassdict", "=", "cls", ".", "__dict__", "try", ":", "return", "klassdict", "[", "\"_typed_fields\"", "]", "except", "KeyError", ":", "fields", "=", "cls", ".", "typed_fields_with_attrnames", "(", ")", "cls", ".", "_typed_fields", "=", "tuple", "(", "field", "for", "_", ",", "field", "in", "fields", ")", "return", "cls", ".", "_typed_fields" ]

[ "Return", "a", "tuple", "of", "this", "entity", "s", "TypedFields", "." ]

[ "def", "to_obj", "(", "self", ",", "ns_info", "=", "None", ")", ":", "if", "ns_info", ":", "ns_info", ".", "collect", "(", "self", ")", "# null behavior for classes that inherit from Entity but do not", "# have _binding_class", "if", "not", "hasattr", "(", "self", ",", "\"_binding_class\"", ")", ":", "return", "None", "entity_obj", "=", "self", ".", "_binding_class", "(", ")", "for", "field", ",", "val", "in", "six", ".", "iteritems", "(", "self", ".", "_fields", ")", ":", "# EntityLists with no list items should be dropped", "if", "isinstance", "(", "val", ",", "EntityList", ")", "and", "len", "(", "val", ")", "==", "0", ":", "val", "=", "None", "elif", "field", ".", "multiple", ":", "if", "val", ":", "val", "=", "[", "_objectify", "(", "field", ",", "x", ",", "ns_info", ")", "for", "x", "in", "val", "]", "else", ":", "val", "=", "[", "]", "else", ":", "val", "=", "_objectify", "(", "field", ",", "val", ",", "ns_info", ")", "setattr", "(", "entity_obj", ",", "field", ".", "name", ",", "val", ")", "self", ".", "_finalize_obj", "(", "entity_obj", ")", "return", "entity_obj" ]

[ "Convert", "to", "a", "GenerateDS", "binding", "object", "." ]

[ "def", "to_dict", "(", "self", ")", ":", "entity_dict", "=", "{", "}", "for", "field", ",", "val", "in", "six", ".", "iteritems", "(", "self", ".", "_fields", ")", ":", "if", "field", ".", "multiple", ":", "if", "val", ":", "val", "=", "[", "_dictify", "(", "field", ",", "x", ")", "for", "x", "in", "val", "]", "else", ":", "val", "=", "[", "]", "else", ":", "val", "=", "_dictify", "(", "field", ",", "val", ")", "# Only add non-None objects or non-empty lists", "if", "val", "is", "not", "None", "and", "val", "!=", "[", "]", ":", "entity_dict", "[", "field", ".", "key_name", "]", "=", "val", "self", ".", "_finalize_dict", "(", "entity_dict", ")", "return", "entity_dict" ]

[ "Convert", "to", "a", "dict" ]