Datasets:

semeru

/

code-text-python

like 4

[ "def", "_add_uniq_value_to_dict_bf", "(", "d", ",", "k", ",", "v", ")", ":", "prev", "=", "d", ".", "get", "(", "k", ")", "if", "prev", "is", "None", ":", "d", "[", "k", "]", "=", "v", "elif", "isinstance", "(", "prev", ",", "list", ")", ":", "if", "not", "isinstance", "(", "v", ",", "list", ")", ":", "v", "=", "[", "v", "]", "for", "sel", "in", "v", ":", "found", "=", "False", "for", "el", "in", "prev", ":", "if", "el", "==", "sel", ":", "found", "=", "True", "break", "if", "not", "found", ":", "prev", ".", "append", "(", "sel", ")", "else", ":", "if", "isinstance", "(", "v", ",", "list", ")", ":", "prev", "=", "[", "prev", "]", "for", "sel", "in", "v", ":", "found", "=", "False", "for", "el", "in", "prev", ":", "if", "el", "==", "sel", ":", "found", "=", "True", "break", "if", "not", "found", ":", "prev", ".", "append", "(", "sel", ")", "if", "len", "(", "prev", ")", ">", "1", ":", "d", "[", "k", "]", "=", "prev", "elif", "prev", "!=", "v", ":", "d", "[", "k", "]", "=", "[", "prev", ",", "v", "]" ]

[ "Like", "_add_value_to_dict_bf", "but", "will", "not", "add", "v", "if", "another", "element", "in", "under", "key", "k", "has", "the", "same", "value", "." ]

[ "def", "_debug_dump_dom", "(", "el", ")", ":", "import", "xml", ".", "dom", ".", "minidom", "s", "=", "[", "el", ".", "nodeName", "]", "att_container", "=", "el", ".", "attributes", "for", "i", "in", "range", "(", "att_container", ".", "length", ")", ":", "attr", "=", "att_container", ".", "item", "(", "i", ")", "s", ".", "append", "(", "' @{a}=\"{v}\"'", ".", "format", "(", "a", "=", "attr", ".", "name", ",", "v", "=", "attr", ".", "value", ")", ")", "for", "c", "in", "el", ".", "childNodes", ":", "if", "c", ".", "nodeType", "==", "xml", ".", "dom", ".", "minidom", ".", "Node", ".", "TEXT_NODE", ":", "s", ".", "append", "(", "' {a} type=\"TEXT\" data=\"{d}\"'", ".", "format", "(", "a", "=", "c", ".", "nodeName", ",", "d", "=", "c", ".", "data", ")", ")", "else", ":", "s", ".", "append", "(", "' {a} child'", ".", "format", "(", "a", "=", "c", ".", "nodeName", ")", ")", "return", "'\\n'", ".", "join", "(", "s", ")" ]

[ "Debugging", "helper", ".", "Prints", "out", "el", "contents", "." ]

[ "def", "_convert_hbf_meta_val_for_xml", "(", "key", ",", "val", ")", ":", "if", "isinstance", "(", "val", ",", "list", ")", ":", "return", "[", "_convert_hbf_meta_val_for_xml", "(", "key", ",", "i", ")", "for", "i", "in", "val", "]", "is_literal", "=", "True", "content", "=", "None", "if", "isinstance", "(", "val", ",", "dict", ")", ":", "ret", "=", "val", "if", "'@href'", "in", "val", ":", "is_literal", "=", "False", "else", ":", "content", "=", "val", ".", "get", "(", "'$'", ")", "if", "isinstance", "(", "content", ",", "dict", ")", "and", "_contains_hbf_meta_keys", "(", "val", ")", ":", "is_literal", "=", "False", "else", ":", "ret", "=", "{", "}", "content", "=", "val", "if", "is_literal", ":", "ret", ".", "setdefault", "(", "'@xsi:type'", ",", "'nex:LiteralMeta'", ")", "ret", ".", "setdefault", "(", "'@property'", ",", "key", ")", "if", "content", "is", "not", "None", ":", "ret", ".", "setdefault", "(", "'@datatype'", ",", "_python_instance_to_nexml_meta_datatype", "(", "content", ")", ")", "if", "ret", "is", "not", "val", ":", "ret", "[", "'$'", "]", "=", "content", "else", ":", "ret", ".", "setdefault", "(", "'@xsi:type'", ",", "'nex:ResourceMeta'", ")", "ret", ".", "setdefault", "(", "'@rel'", ",", "key", ")", "return", "ret" ]

[ "Convert", "to", "a", "BadgerFish", "-", "style", "dict", "for", "addition", "to", "a", "dict", "suitable", "for", "addition", "to", "XML", "tree", "or", "for", "v1", ".", "0", "to", "v0", ".", "0", "conversion", "." ]

[ "def", "find_nested_meta_first", "(", "d", ",", "prop_name", ",", "version", ")", ":", "if", "_is_badgerfish_version", "(", "version", ")", ":", "return", "find_nested_meta_first_bf", "(", "d", ",", "prop_name", ")", "p", "=", "'^'", "+", "prop_name", "return", "d", ".", "get", "(", "p", ")" ]

[ "Returns", "obj", ".", "for", "badgerfish", "and", "val", "for", "hbf", ".", "Appropriate", "for", "nested", "literals" ]

[ "def", "decode", "(", "value", ":", "str", ")", "->", "Union", "[", "str", ",", "None", ",", "bool", ",", "int", ",", "float", "]", ":", "assert", "value", ".", "isdigit", "(", ")", "or", "value", "[", "0", "]", "==", "'-'", "and", "value", "[", "1", ":", "]", ".", "isdigit", "(", ")", "if", "-", "I32_BOUND", "<=", "int", "(", "value", ")", "<", "I32_BOUND", ":", "# it's an i32: it is its own encoding", "return", "int", "(", "value", ")", "elif", "int", "(", "value", ")", "==", "I32_BOUND", ":", "return", "None", "(", "prefix", ",", "value", ")", "=", "(", "int", "(", "value", "[", "0", "]", ")", ",", "int", "(", "value", "[", "1", ":", "]", ")", ")", "ival", "=", "int", "(", "value", ")", "-", "I32_BOUND", "if", "ival", "==", "0", ":", "return", "''", "# special case: empty string encodes as 2**31", "elif", "ival", "==", "1", ":", "return", "False", "# sentinel for bool False", "elif", "ival", "==", "2", ":", "return", "True", "# sentinel for bool True", "blen", "=", "ceil", "(", "log", "(", "ival", ",", "16", ")", "/", "2", ")", "ibytes", "=", "unhexlify", "(", "ival", ".", "to_bytes", "(", "blen", ",", "'big'", ")", ")", "return", "DECODE_PREFIX", ".", "get", "(", "prefix", ",", "str", ")", "(", "ibytes", ".", "decode", "(", ")", ")" ]

[ "Decode", "encoded", "credential", "attribute", "value", "." ]

[ "def", "validate_params_match", "(", "method", ",", "parameters", ")", ":", "argspec", "=", "inspect", ".", "getargspec", "(", "method", ")", "# pylint: disable=deprecated-method", "default_length", "=", "len", "(", "argspec", ".", "defaults", ")", "if", "argspec", ".", "defaults", "is", "not", "None", "else", "0", "if", "isinstance", "(", "parameters", ",", "list", ")", ":", "if", "len", "(", "parameters", ")", ">", "len", "(", "argspec", ".", "args", ")", "and", "argspec", ".", "varargs", "is", "None", ":", "raise", "InvalidParamsError", "(", "\"Too many parameters\"", ")", "remaining_parameters", "=", "len", "(", "argspec", ".", "args", ")", "-", "len", "(", "parameters", ")", "if", "remaining_parameters", ">", "default_length", ":", "raise", "InvalidParamsError", "(", "\"Not enough parameters\"", ")", "elif", "isinstance", "(", "parameters", ",", "dict", ")", ":", "missing_parameters", "=", "[", "key", "for", "key", "in", "argspec", ".", "args", "if", "key", "not", "in", "parameters", "]", "default_parameters", "=", "set", "(", "argspec", ".", "args", "[", "len", "(", "argspec", ".", "args", ")", "-", "default_length", ":", "]", ")", "for", "key", "in", "missing_parameters", ":", "if", "key", "not", "in", "default_parameters", ":", "raise", "InvalidParamsError", "(", "\"Parameter {} has not been satisfied\"", ".", "format", "(", "key", ")", ")", "extra_params", "=", "[", "key", "for", "key", "in", "parameters", "if", "key", "not", "in", "argspec", ".", "args", "]", "if", "len", "(", "extra_params", ")", ">", "0", "and", "argspec", ".", "keywords", "is", "None", ":", "raise", "InvalidParamsError", "(", "\"Too many parameters\"", ")" ]

[ "Validates", "that", "the", "given", "parameters", "are", "exactly", "the", "method", "s", "declared", "parameters", "." ]

[ "def", "check_types", "(", "parameters", ",", "parameter_types", ",", "strict_floats", ")", ":", "for", "name", ",", "parameter_type", "in", "parameter_types", ".", "items", "(", ")", ":", "if", "name", "not", "in", "parameters", ":", "raise", "InvalidParamsError", "(", "\"Parameter '{}' is missing.\"", ".", "format", "(", "name", ")", ")", "if", "not", "_is_instance", "(", "parameters", "[", "name", "]", ",", "parameter_type", ",", "strict_floats", ")", ":", "raise", "InvalidParamsError", "(", "\"Value '{}' for parameter '{}' is not of expected type {}.\"", ".", "format", "(", "parameters", "[", "name", "]", ",", "name", ",", "parameter_type", ")", ")" ]

[ "Checks", "that", "the", "given", "parameters", "have", "the", "correct", "types", "." ]

[ "def", "check_type_declaration", "(", "parameter_names", ",", "parameter_types", ")", ":", "if", "len", "(", "parameter_names", ")", "!=", "len", "(", "parameter_types", ")", ":", "raise", "Exception", "(", "\"Number of method parameters ({}) does not match number of \"", "\"declared types ({})\"", ".", "format", "(", "len", "(", "parameter_names", ")", ",", "len", "(", "parameter_types", ")", ")", ")", "for", "parameter_name", "in", "parameter_names", ":", "if", "parameter_name", "not", "in", "parameter_types", ":", "raise", "Exception", "(", "\"Parameter '{}' does not have a declared type\"", ".", "format", "(", "parameter_name", ")", ")" ]

[ "Checks", "that", "exactly", "the", "given", "parameter", "names", "have", "declared", "types", "." ]

[ "def", "check_return_type", "(", "value", ",", "expected_type", ",", "strict_floats", ")", ":", "if", "expected_type", "is", "None", ":", "if", "value", "is", "not", "None", ":", "raise", "InvalidReturnTypeError", "(", "\"Returned value is '{}' but None was expected\"", ".", "format", "(", "value", ")", ")", "elif", "not", "_is_instance", "(", "value", ",", "expected_type", ",", "strict_floats", ")", ":", "raise", "InvalidReturnTypeError", "(", "\"Type of return value '{}' does not match expected type {}\"", ".", "format", "(", "value", ",", "expected_type", ")", ")" ]

[ "Checks", "that", "the", "given", "return", "value", "has", "the", "correct", "type", "." ]

[ "def", "_make_phylesystem_cache_region", "(", "*", "*", "kwargs", ")", ":", "global", "_CACHE_REGION_CONFIGURED", ",", "_REGION", "if", "_CACHE_REGION_CONFIGURED", ":", "return", "_REGION", "_CACHE_REGION_CONFIGURED", "=", "True", "try", ":", "# noinspection PyPackageRequirements", "from", "dogpile", ".", "cache", "import", "make_region", "except", ":", "_LOG", ".", "debug", "(", "'dogpile.cache not available'", ")", "return", "region", "=", "None", "trial_key", "=", "'test_key'", "trial_val", "=", "{", "'test_val'", ":", "[", "4", ",", "3", "]", "}", "trying_redis", "=", "True", "if", "trying_redis", ":", "try", ":", "a", "=", "{", "'host'", ":", "'localhost'", ",", "'port'", ":", "6379", ",", "'db'", ":", "0", ",", "# default is 0", "'redis_expiration_time'", ":", "60", "*", "60", "*", "24", "*", "2", ",", "# 2 days", "'distributed_lock'", ":", "False", "# True if multiple processes will use redis", "}", "region", "=", "make_region", "(", ")", ".", "configure", "(", "'dogpile.cache.redis'", ",", "arguments", "=", "a", ")", "_LOG", ".", "debug", "(", "'cache region set up with cache.redis.'", ")", "_LOG", ".", "debug", "(", "'testing redis caching...'", ")", "region", ".", "set", "(", "trial_key", ",", "trial_val", ")", "assert", "trial_val", "==", "region", ".", "get", "(", "trial_key", ")", "_LOG", ".", "debug", "(", "'redis caching works'", ")", "region", ".", "delete", "(", "trial_key", ")", "_REGION", "=", "region", "return", "region", "except", ":", "_LOG", ".", "debug", "(", "'redis cache set up failed.'", ")", "region", "=", "None", "trying_file_dbm", "=", "False", "if", "trying_file_dbm", ":", "_LOG", ".", "debug", "(", "'Going to try dogpile.cache.dbm ...'", ")", "first_par", "=", "_get_phylesystem_parent", "(", "*", "*", "kwargs", ")", "[", "0", "]", "cache_db_dir", "=", "os", ".", "path", ".", "split", "(", "first_par", ")", "[", "0", "]", "cache_db", "=", "os", ".", "path", ".", "join", "(", "cache_db_dir", ",", "'phylesystem-cachefile.dbm'", ")", "_LOG", ".", "debug", "(", "'dogpile.cache region using \"{}\"'", ".", "format", "(", "cache_db", ")", ")", "try", ":", "a", "=", "{", "'filename'", ":", "cache_db", "}", "region", "=", "make_region", "(", ")", ".", "configure", "(", "'dogpile.cache.dbm'", ",", "expiration_time", "=", "36000", ",", "arguments", "=", "a", ")", "_LOG", ".", "debug", "(", "'cache region set up with cache.dbm.'", ")", "_LOG", ".", "debug", "(", "'testing anydbm caching...'", ")", "region", ".", "set", "(", "trial_key", ",", "trial_val", ")", "assert", "trial_val", "==", "region", ".", "get", "(", "trial_key", ")", "_LOG", ".", "debug", "(", "'anydbm caching works'", ")", "region", ".", "delete", "(", "trial_key", ")", "_REGION", "=", "region", "return", "region", "except", ":", "_LOG", ".", "debug", "(", "'anydbm cache set up failed'", ")", "_LOG", ".", "debug", "(", "'exception in the configuration of the cache.'", ")", "_LOG", ".", "debug", "(", "'Phylesystem will not use caching'", ")", "return", "None" ]

[ "Only", "intended", "to", "be", "called", "by", "the", "Phylesystem", "singleton", "." ]

[ "def", "path_for_doc", "(", "self", ",", "doc_id", ")", ":", "full_path", "=", "self", ".", "path_for_doc_fn", "(", "self", ".", "repo", ",", "doc_id", ")", "# _LOG.debug('>>>>>>>>>> GitActionBase.path_for_doc_fn: {}'.format(self.path_for_doc_fn))", "# _LOG.debug('>>>>>>>>>> GitActionBase.path_for_doc returning: [{}]'.format(full_path))", "return", "full_path" ]

[ "Returns", "doc_dir", "and", "doc_filepath", "for", "doc_id", "." ]

[ "def", "current_branch", "(", "self", ")", ":", "branch_name", "=", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"symbolic-ref\"", ",", "\"HEAD\"", ")", "return", "branch_name", ".", "replace", "(", "'refs/heads/'", ",", "''", ")", ".", "strip", "(", ")" ]

[ "Return", "the", "current", "branch", "name" ]

[ "def", "branch_exists", "(", "self", ",", "branch", ")", ":", "try", ":", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rev-parse\"", ",", "branch", ")", "except", "sh", ".", "ErrorReturnCode", ":", "return", "False", "return", "True" ]

[ "Returns", "true", "or", "false", "depending", "on", "if", "a", "branch", "exists" ]

[ "def", "fetch", "(", "self", ",", "remote", "=", "'origin'", ")", ":", "git", "(", "self", ".", "gitdir", ",", "\"fetch\"", ",", "remote", ",", "_env", "=", "self", ".", "env", "(", ")", ")" ]

[ "fetch", "from", "a", "remote" ]

[ "def", "get_version_history_for_file", "(", "self", ",", "filepath", ")", ":", "# define the desired fields for logout output, matching the order in these lists!", "GIT_COMMIT_FIELDS", "=", "[", "'id'", ",", "'author_name'", ",", "'author_email'", ",", "'date'", ",", "'date_ISO_8601'", ",", "'relative_date'", ",", "'message_subject'", ",", "'message_body'", "]", "GIT_LOG_FORMAT", "=", "[", "'%H'", ",", "'%an'", ",", "'%ae'", ",", "'%aD'", ",", "'%ai'", ",", "'%ar'", ",", "'%s'", ",", "'%b'", "]", "# make the final format string, using standard ASCII field/record delimiters", "GIT_LOG_FORMAT", "=", "'%x1f'", ".", "join", "(", "GIT_LOG_FORMAT", ")", "+", "'%x1e'", "try", ":", "log", "=", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "'--no-pager'", ",", "'log'", ",", "'--format=%s'", "%", "GIT_LOG_FORMAT", ",", "'--follow'", ",", "# Track file's history when moved/renamed...", "'--find-renames=100%'", ",", "# ... but only if the contents are identical!", "'--'", ",", "filepath", ")", "# _LOG.debug('log said \"{}\"'.format(log))", "log", "=", "log", ".", "strip", "(", "'\\n\\x1e'", ")", ".", "split", "(", "\"\\x1e\"", ")", "log", "=", "[", "row", ".", "strip", "(", ")", ".", "split", "(", "\"\\x1f\"", ")", "for", "row", "in", "log", "]", "log", "=", "[", "dict", "(", "zip", "(", "GIT_COMMIT_FIELDS", ",", "row", ")", ")", "for", "row", "in", "log", "]", "except", ":", "_LOG", ".", "exception", "(", "'git log failed'", ")", "raise", "return", "log" ]

[ "Return", "a", "dict", "representation", "of", "this", "file", "s", "commit", "history" ]

[ "def", "_add_and_commit", "(", "self", ",", "doc_filepath", ",", "author", ",", "commit_msg", ")", ":", "try", ":", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"add\"", ",", "doc_filepath", ")", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"commit\"", ",", "author", "=", "author", ",", "message", "=", "commit_msg", ")", "except", "Exception", "as", "e", ":", "# We can ignore this if no changes are new,", "# otherwise raise a 400", "if", "\"nothing to commit\"", "in", "e", ".", "message", ":", "# @EJM is this dangerous?", "_LOG", ".", "debug", "(", "'\"nothing to commit\" found in error response'", ")", "else", ":", "_LOG", ".", "exception", "(", "'\"git commit\" failed'", ")", "self", ".", "reset_hard", "(", ")", "raise" ]

[ "Low", "level", "function", "used", "internally", "when", "you", "have", "an", "absolute", "filepath", "to", "add", "and", "commit" ]

[ "def", "_remove_document", "(", "self", ",", "gh_user", ",", "doc_id", ",", "parent_sha", ",", "author", ",", "commit_msg", "=", "None", ")", ":", "# _LOG.debug(\"@@@@@@@@ GitActionBase._remove_document, doc_id={}\".format(doc_id))", "doc_filepath", "=", "self", ".", "path_for_doc", "(", "doc_id", ")", "# _LOG.debug(\"@@@@@@@@ GitActionBase._remove_document, doc_filepath={}\".format(doc_filepath))", "branch", "=", "self", ".", "create_or_checkout_branch", "(", "gh_user", ",", "doc_id", ",", "parent_sha", ")", "prev_file_sha", "=", "None", "if", "commit_msg", "is", "None", ":", "msg", "=", "\"Delete document '%s' via OpenTree API\"", "%", "doc_id", "else", ":", "msg", "=", "commit_msg", "if", "os", ".", "path", ".", "exists", "(", "doc_filepath", ")", ":", "prev_file_sha", "=", "self", ".", "get_blob_sha_for_file", "(", "doc_filepath", ")", "if", "self", ".", "doc_type", "==", "'nexson'", ":", "# delete the parent directory entirely", "doc_dir", "=", "os", ".", "path", ".", "split", "(", "doc_filepath", ")", "[", "0", "]", "# _LOG.debug(\"@@@@@@@@ GitActionBase._remove_document, doc_dir={}\".format(doc_dir))", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rm\"", ",", "\"-rf\"", ",", "doc_dir", ")", "elif", "self", ".", "doc_type", "in", "(", "'collection'", ",", "'favorites'", ",", "'amendment'", ")", ":", "# delete just the target file", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rm\"", ",", "doc_filepath", ")", "else", ":", "raise", "NotImplementedError", "(", "\"No deletion rules for doc_type '{}'\"", ".", "format", "(", "self", ".", "doc_type", ")", ")", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"commit\"", ",", "author", "=", "author", ",", "message", "=", "msg", ")", "new_sha", "=", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rev-parse\"", ",", "\"HEAD\"", ")", ".", "strip", "(", ")", "return", "{", "'commit_sha'", ":", "new_sha", ",", "'branch'", ":", "branch", ",", "'prev_file_sha'", ":", "prev_file_sha", ",", "}" ]

[ "Remove", "a", "document", "Remove", "a", "document", "on", "the", "given", "branch", "and", "attribute", "the", "commit", "to", "author", ".", "Returns", "the", "SHA", "of", "the", "commit", "on", "branch", "." ]

[ "def", "write_document", "(", "self", ",", "gh_user", ",", "doc_id", ",", "file_content", ",", "branch", ",", "author", ",", "commit_msg", "=", "None", ")", ":", "parent_sha", "=", "None", "fc", "=", "tempfile", ".", "NamedTemporaryFile", "(", ")", "# N.B. we currently assume file_content is text/JSON, or should be serialized from a dict", "if", "is_str_type", "(", "file_content", ")", ":", "fc", ".", "write", "(", "file_content", ")", "else", ":", "write_as_json", "(", "file_content", ",", "fc", ")", "fc", ".", "flush", "(", ")", "try", ":", "doc_filepath", "=", "self", ".", "path_for_doc", "(", "doc_id", ")", "doc_dir", "=", "os", ".", "path", ".", "split", "(", "doc_filepath", ")", "[", "0", "]", "if", "parent_sha", "is", "None", ":", "self", ".", "checkout_master", "(", ")", "parent_sha", "=", "self", ".", "get_master_sha", "(", ")", "branch", "=", "self", ".", "create_or_checkout_branch", "(", "gh_user", ",", "doc_id", ",", "parent_sha", ",", "force_branch_name", "=", "True", ")", "# create a document directory if this is a new doc EJM- what if it isn't?", "if", "not", "os", ".", "path", ".", "isdir", "(", "doc_dir", ")", ":", "os", ".", "makedirs", "(", "doc_dir", ")", "shutil", ".", "copy", "(", "fc", ".", "name", ",", "doc_filepath", ")", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"add\"", ",", "doc_filepath", ")", "if", "commit_msg", "is", "None", ":", "commit_msg", "=", "\"Update document '%s' via OpenTree API\"", "%", "doc_id", "try", ":", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"commit\"", ",", "author", "=", "author", ",", "message", "=", "commit_msg", ")", "except", "Exception", "as", "e", ":", "# We can ignore this if no changes are new,", "# otherwise raise a 400", "if", "\"nothing to commit\"", "in", "e", ".", "message", ":", "# @EJM is this dangerous?", "pass", "else", ":", "_LOG", ".", "exception", "(", "'\"git commit\" failed'", ")", "self", ".", "reset_hard", "(", ")", "raise", "new_sha", "=", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rev-parse\"", ",", "\"HEAD\"", ")", "except", "Exception", "as", "e", ":", "_LOG", ".", "exception", "(", "'write_document exception'", ")", "raise", "GitWorkflowError", "(", "\"Could not write to document #%s ! Details: \\n%s\"", "%", "(", "doc_id", ",", "e", ".", "message", ")", ")", "finally", ":", "fc", ".", "close", "(", ")", "return", "new_sha" ]

[ "Given", "a", "document", "id", "temporary", "filename", "of", "content", "branch", "and", "auth_info" ]

[ "def", "write_doc_from_tmpfile", "(", "self", ",", "doc_id", ",", "tmpfi", ",", "parent_sha", ",", "auth_info", ",", "commit_msg", "=", "''", ",", "doctype_display_name", "=", "\"document\"", ")", ":", "gh_user", ",", "author", "=", "get_user_author", "(", "auth_info", ")", "doc_filepath", "=", "self", ".", "path_for_doc", "(", "doc_id", ")", "doc_dir", "=", "os", ".", "path", ".", "split", "(", "doc_filepath", ")", "[", "0", "]", "if", "parent_sha", "is", "None", ":", "self", ".", "checkout_master", "(", ")", "parent_sha", "=", "self", ".", "get_master_sha", "(", ")", "branch", "=", "self", ".", "create_or_checkout_branch", "(", "gh_user", ",", "doc_id", ",", "parent_sha", ")", "# build complete (probably type-specific) commit message", "default_commit_msg", "=", "\"Update %s '%s' via OpenTree API\"", "%", "(", "doctype_display_name", ",", "doc_id", ")", "if", "commit_msg", ":", "commit_msg", "=", "\"%s\\n\\n(%s)\"", "%", "(", "commit_msg", ",", "default_commit_msg", ")", "else", ":", "commit_msg", "=", "default_commit_msg", "# create a doc directory if this is a new document EJM- what if it isn't?", "if", "not", "os", ".", "path", ".", "isdir", "(", "doc_dir", ")", ":", "os", ".", "makedirs", "(", "doc_dir", ")", "if", "os", ".", "path", ".", "exists", "(", "doc_filepath", ")", ":", "prev_file_sha", "=", "self", ".", "get_blob_sha_for_file", "(", "doc_filepath", ")", "else", ":", "prev_file_sha", "=", "None", "shutil", ".", "copy", "(", "tmpfi", ".", "name", ",", "doc_filepath", ")", "self", ".", "_add_and_commit", "(", "doc_filepath", ",", "author", ",", "commit_msg", ")", "new_sha", "=", "git", "(", "self", ".", "gitdir", ",", "self", ".", "gitwd", ",", "\"rev-parse\"", ",", "\"HEAD\"", ")", "_LOG", ".", "debug", "(", "'Committed document \"{i}\" to branch \"{b}\" commit SHA: \"{s}\"'", ".", "format", "(", "i", "=", "doc_id", ",", "b", "=", "branch", ",", "s", "=", "new_sha", ".", "strip", "(", ")", ")", ")", "return", "{", "'commit_sha'", ":", "new_sha", ".", "strip", "(", ")", ",", "'branch'", ":", "branch", ",", "'prev_file_sha'", ":", "prev_file_sha", ",", "}" ]

[ "Given", "a", "doc_id", "temporary", "filename", "of", "content", "branch", "and", "auth_info" ]

[ "def", "remove_amendment", "(", "self", ",", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "=", "None", ",", "commit_msg", "=", "None", ")", ":", "if", "fourth_arg", "is", "None", ":", "amendment_id", ",", "branch_name", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", "gh_user", "=", "branch_name", ".", "split", "(", "'_amendment_'", ")", "[", "0", "]", "parent_sha", "=", "self", ".", "get_master_sha", "(", ")", "else", ":", "gh_user", ",", "amendment_id", ",", "parent_sha", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "if", "commit_msg", "is", "None", ":", "commit_msg", "=", "\"Delete Amendment '%s' via OpenTree API\"", "%", "amendment_id", "return", "self", ".", "_remove_document", "(", "gh_user", ",", "amendment_id", ",", "parent_sha", ",", "author", ",", "commit_msg", ")" ]

[ "Remove", "an", "amendment", "Given", "a", "amendment_id", "branch", "and", "optionally", "an", "author", "remove", "an", "amendment", "on", "the", "given", "branch", "and", "attribute", "the", "commit", "to", "author", ".", "Returns", "the", "SHA", "of", "the", "commit", "on", "branch", "." ]

[ "def", "create", "(", "cls", ",", "community", ",", "record", ",", "user", "=", "None", ",", "expires_at", "=", "None", ",", "notify", "=", "True", ")", ":", "if", "expires_at", "and", "expires_at", "<", "datetime", ".", "utcnow", "(", ")", ":", "raise", "InclusionRequestExpiryTimeError", "(", "community", "=", "community", ",", "record", "=", "record", ")", "if", "community", ".", "has_record", "(", "record", ")", ":", "raise", "InclusionRequestObsoleteError", "(", "community", "=", "community", ",", "record", "=", "record", ")", "try", ":", "# Create inclusion request", "with", "db", ".", "session", ".", "begin_nested", "(", ")", ":", "obj", "=", "cls", "(", "id_community", "=", "community", ".", "id", ",", "id_record", "=", "record", ".", "id", ",", "user", "=", "user", ",", "expires_at", "=", "expires_at", ")", "db", ".", "session", ".", "add", "(", "obj", ")", "except", "(", "IntegrityError", ",", "FlushError", ")", ":", "raise", "InclusionRequestExistsError", "(", "community", "=", "community", ",", "record", "=", "record", ")", "# Send signal", "inclusion_request_created", ".", "send", "(", "current_app", ".", "_get_current_object", "(", ")", ",", "request", "=", "obj", ",", "notify", "=", "notify", ")", "return", "obj" ]

[ "Create", "a", "record", "inclusion", "request", "to", "a", "community", "." ]

[ "def", "get", "(", "cls", ",", "community_id", ",", "record_uuid", ")", ":", "return", "cls", ".", "query", ".", "filter_by", "(", "id_record", "=", "record_uuid", ",", "id_community", "=", "community_id", ")", ".", "one_or_none", "(", ")" ]

[ "Get", "an", "inclusion", "request", "." ]

[ "def", "filter_communities", "(", "cls", ",", "p", ",", "so", ",", "with_deleted", "=", "False", ")", ":", "query", "=", "cls", ".", "query", "if", "with_deleted", "else", "cls", ".", "query", ".", "filter", "(", "cls", ".", "deleted_at", ".", "is_", "(", "None", ")", ")", "if", "p", ":", "p", "=", "p", ".", "replace", "(", "' '", ",", "'%'", ")", "query", "=", "query", ".", "filter", "(", "db", ".", "or_", "(", "cls", ".", "id", ".", "ilike", "(", "'%'", "+", "p", "+", "'%'", ")", ",", "cls", ".", "title", ".", "ilike", "(", "'%'", "+", "p", "+", "'%'", ")", ",", "cls", ".", "description", ".", "ilike", "(", "'%'", "+", "p", "+", "'%'", ")", ",", ")", ")", "if", "so", "in", "current_app", ".", "config", "[", "'COMMUNITIES_SORTING_OPTIONS'", "]", ":", "order", "=", "so", "==", "'title'", "and", "db", ".", "asc", "or", "db", ".", "desc", "query", "=", "query", ".", "order_by", "(", "order", "(", "getattr", "(", "cls", ",", "so", ")", ")", ")", "else", ":", "query", "=", "query", ".", "order_by", "(", "db", ".", "desc", "(", "cls", ".", "ranking", ")", ")", "return", "query" ]

[ "Search", "for", "communities", "." ]

[ "def", "add_record", "(", "self", ",", "record", ")", ":", "key", "=", "current_app", ".", "config", "[", "'COMMUNITIES_RECORD_KEY'", "]", "record", ".", "setdefault", "(", "key", ",", "[", "]", ")", "if", "self", ".", "has_record", "(", "record", ")", ":", "current_app", ".", "logger", ".", "warning", "(", "'Community addition: record {uuid} is already in community '", "'\"{comm}\"'", ".", "format", "(", "uuid", "=", "record", ".", "id", ",", "comm", "=", "self", ".", "id", ")", ")", "else", ":", "record", "[", "key", "]", ".", "append", "(", "self", ".", "id", ")", "record", "[", "key", "]", "=", "sorted", "(", "record", "[", "key", "]", ")", "if", "current_app", ".", "config", "[", "'COMMUNITIES_OAI_ENABLED'", "]", ":", "if", "not", "self", ".", "oaiset", ".", "has_record", "(", "record", ")", ":", "self", ".", "oaiset", ".", "add_record", "(", "record", ")" ]

[ "Add", "a", "record", "to", "the", "community", "." ]

[ "def", "remove_record", "(", "self", ",", "record", ")", ":", "if", "not", "self", ".", "has_record", "(", "record", ")", ":", "current_app", ".", "logger", ".", "warning", "(", "'Community removal: record {uuid} was not in community '", "'\"{comm}\"'", ".", "format", "(", "uuid", "=", "record", ".", "id", ",", "comm", "=", "self", ".", "id", ")", ")", "else", ":", "key", "=", "current_app", ".", "config", "[", "'COMMUNITIES_RECORD_KEY'", "]", "record", "[", "key", "]", "=", "[", "c", "for", "c", "in", "record", "[", "key", "]", "if", "c", "!=", "self", ".", "id", "]", "if", "current_app", ".", "config", "[", "'COMMUNITIES_OAI_ENABLED'", "]", ":", "if", "self", ".", "oaiset", ".", "has_record", "(", "record", ")", ":", "self", ".", "oaiset", ".", "remove_record", "(", "record", ")" ]

[ "Remove", "an", "already", "accepted", "record", "from", "the", "community", "." ]

[ "def", "accept_record", "(", "self", ",", "record", ")", ":", "with", "db", ".", "session", ".", "begin_nested", "(", ")", ":", "req", "=", "InclusionRequest", ".", "get", "(", "self", ".", "id", ",", "record", ".", "id", ")", "if", "req", "is", "None", ":", "raise", "InclusionRequestMissingError", "(", "community", "=", "self", ",", "record", "=", "record", ")", "req", ".", "delete", "(", ")", "self", ".", "add_record", "(", "record", ")", "self", ".", "last_record_accepted", "=", "datetime", ".", "utcnow", "(", ")" ]

[ "Accept", "a", "record", "for", "inclusion", "in", "the", "community", "." ]

[ "def", "reject_record", "(", "self", ",", "record", ")", ":", "with", "db", ".", "session", ".", "begin_nested", "(", ")", ":", "req", "=", "InclusionRequest", ".", "get", "(", "self", ".", "id", ",", "record", ".", "id", ")", "if", "req", "is", "None", ":", "raise", "InclusionRequestMissingError", "(", "community", "=", "self", ",", "record", "=", "record", ")", "req", ".", "delete", "(", ")" ]

[ "Reject", "a", "record", "for", "inclusion", "in", "the", "community", "." ]

[ "def", "delete", "(", "self", ")", ":", "if", "self", ".", "deleted_at", "is", "not", "None", ":", "raise", "CommunitiesError", "(", "community", "=", "self", ")", "else", ":", "self", ".", "deleted_at", "=", "datetime", ".", "utcnow", "(", ")" ]

[ "Mark", "the", "community", "for", "deletion", "." ]

[ "def", "logo_url", "(", "self", ")", ":", "if", "self", ".", "logo_ext", ":", "return", "'/api/files/{bucket}/{key}'", ".", "format", "(", "bucket", "=", "current_app", ".", "config", "[", "'COMMUNITIES_BUCKET_UUID'", "]", ",", "key", "=", "'{0}/logo.{1}'", ".", "format", "(", "self", ".", "id", ",", "self", ".", "logo_ext", ")", ",", ")", "return", "None" ]

[ "Get", "URL", "to", "collection", "logo", "." ]

[ "def", "oaiset", "(", "self", ")", ":", "if", "current_app", ".", "config", "[", "'COMMUNITIES_OAI_ENABLED'", "]", ":", "from", "invenio_oaiserver", ".", "models", "import", "OAISet", "return", "OAISet", ".", "query", ".", "filter_by", "(", "spec", "=", "self", ".", "oaiset_spec", ")", ".", "one", "(", ")", "else", ":", "return", "None" ]

[ "Return", "the", "corresponding", "OAISet", "for", "given", "community", "." ]

[ "def", "oaiset_url", "(", "self", ")", ":", "return", "url_for", "(", "'invenio_oaiserver.response'", ",", "verb", "=", "'ListRecords'", ",", "metadataPrefix", "=", "'oai_dc'", ",", "set", "=", "self", ".", "oaiset_spec", ",", "_external", "=", "True", ")" ]

[ "Return", "the", "OAISet", "URL", "for", "given", "community", "." ]

[ "def", "version_id", "(", "self", ")", ":", "return", "hashlib", ".", "sha1", "(", "'{0}__{1}'", ".", "format", "(", "self", ".", "id", ",", "self", ".", "updated", ")", ".", "encode", "(", "'utf-8'", ")", ")", ".", "hexdigest", "(", ")" ]

[ "Return", "the", "version", "of", "the", "community", "." ]

[ "def", "get_featured_or_none", "(", "cls", ",", "start_date", "=", "None", ")", ":", "start_date", "=", "start_date", "or", "datetime", ".", "utcnow", "(", ")", "comm", "=", "cls", ".", "query", ".", "filter", "(", "FeaturedCommunity", ".", "start_date", "<=", "start_date", ")", ".", "order_by", "(", "cls", ".", "start_date", ".", "desc", "(", ")", ")", ".", "first", "(", ")", "return", "comm", "if", "comm", "is", "None", "else", "comm", ".", "community" ]

[ "Get", "the", "latest", "featured", "community", "." ]

[ "def", "getConnectorVersion", "(", "self", ")", ":", "result", "=", "asyncResult", "(", ")", "data", "=", "self", ".", "_getURL", "(", "\"/\"", ",", "versioned", "=", "False", ")", "result", ".", "fill", "(", "data", ")", "if", "data", ".", "status_code", "==", "200", ":", "result", ".", "error", "=", "False", "else", ":", "result", ".", "error", "=", "response_codes", "(", "\"get_mdc_version\"", ",", "data", ".", "status_code", ")", "result", ".", "is_done", "=", "True", "return", "result" ]

[ "GET", "the", "current", "Connector", "version", "." ]

[ "def", "setHandler", "(", "self", ",", "handler", ",", "cbfn", ")", ":", "if", "handler", "==", "\"async-responses\"", ":", "self", ".", "async_responses_callback", "=", "cbfn", "elif", "handler", "==", "\"registrations-expired\"", ":", "self", ".", "registrations_expired_callback", "=", "cbfn", "elif", "handler", "==", "\"de-registrations\"", ":", "self", ".", "de_registrations_callback", "=", "cbfn", "elif", "handler", "==", "\"reg-updates\"", ":", "self", ".", "reg_updates_callback", "=", "cbfn", "elif", "handler", "==", "\"registrations\"", ":", "self", ".", "registrations_callback", "=", "cbfn", "elif", "handler", "==", "\"notifications\"", ":", "self", ".", "notifications_callback", "=", "cbfn", "else", ":", "self", ".", "log", ".", "warn", "(", "\"'%s' is not a legitimate notification channel option. Please check your spelling.\"", ",", "handler", ")" ]

[ "Register", "a", "handler", "for", "a", "particular", "notification", "type", ".", "These", "are", "the", "types", "of", "notifications", "that", "are", "acceptable", ".", "|", "async", "-", "responses", "|", "registrations", "-", "expired", "|", "de", "-", "registrations", "|", "reg", "-", "updates", "|", "registrations", "|", "notifications" ]

[ "def", "as_python", "(", "self", ",", "infile", ",", "include_original_shex", ":", "bool", "=", "False", ")", ":", "self", ".", "_context", ".", "resolve_circular_references", "(", ")", "# add forwards for any circular entries", "body", "=", "''", "for", "k", "in", "self", ".", "_context", ".", "ordered_elements", "(", ")", ":", "v", "=", "self", ".", "_context", ".", "grammarelts", "[", "k", "]", "if", "isinstance", "(", "v", ",", "(", "JSGLexerRuleBlock", ",", "JSGObjectExpr", ")", ")", ":", "body", "+=", "v", ".", "as_python", "(", "k", ")", "if", "isinstance", "(", "v", ",", "JSGObjectExpr", ")", "and", "not", "self", ".", "_context", ".", "has_typeid", ":", "self", ".", "_context", ".", "directives", ".", "append", "(", "f'_CONTEXT.TYPE_EXCEPTIONS.append(\"{k}\")'", ")", "elif", "isinstance", "(", "v", ",", "JSGForwardRef", ")", ":", "pass", "elif", "isinstance", "(", "v", ",", "(", "JSGValueType", ",", "JSGArrayExpr", ")", ")", ":", "body", "+=", "f\"\\n\\n\\n{k} = {v.signature_type()}\"", "else", ":", "raise", "NotImplementedError", "(", "\"Unknown grammar elt for {}\"", ".", "format", "(", "k", ")", ")", "self", ".", "_context", ".", "forward_refs", ".", "pop", "(", "k", ",", "None", ")", "body", "=", "'\\n'", "+", "'\\n'", ".", "join", "(", "self", ".", "_context", ".", "directives", ")", "+", "body", "return", "_jsg_python_template", ".", "format", "(", "infile", "=", "infile", ",", "original_shex", "=", "'# '", "+", "self", ".", "text", "if", "include_original_shex", "else", "\"\"", ",", "version", "=", "__version__", ",", "gendate", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "strftime", "(", "\"%Y-%m-%d %H:%M\"", ")", ",", "body", "=", "body", ")" ]

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

[ "def", "__getDummyDateList", "(", ")", ":", "D", "=", "[", "]", "for", "y", "in", "xrange", "(", "2001", ",", "2010", ")", ":", "for", "d", "in", "xrange", "(", "1", ",", "365", ",", "1", ")", ":", "D", ".", "append", "(", "'A%04d%03d'", "%", "(", "y", ",", "d", ")", ")", "return", "D" ]

[ "Generate", "a", "dummy", "date", "list", "for", "testing", "without", "hitting", "the", "server" ]

[ "def", "mkIntDate", "(", "s", ")", ":", "n", "=", "s", ".", "__len__", "(", ")", "d", "=", "int", "(", "s", "[", "-", "(", "n", "-", "1", ")", ":", "n", "]", ")", "return", "d" ]

[ "Convert", "the", "webserver", "formatted", "dates", "to", "an", "integer", "format", "by", "stripping", "the", "leading", "char", "and", "casting" ]

[ "def", "create_id", "(", "self", ",", "prefix", "=", "\"guid\"", ")", ":", "if", "self", ".", "method", "==", "IDGenerator", ".", "METHOD_UUID", ":", "id_", "=", "str", "(", "uuid", ".", "uuid4", "(", ")", ")", "elif", "self", ".", "method", "==", "IDGenerator", ".", "METHOD_INT", ":", "id_", "=", "self", ".", "next_int", "self", ".", "next_int", "+=", "1", "else", ":", "raise", "InvalidMethodError", "(", "self", ".", "method", ")", "return", "\"%s:%s-%s\"", "%", "(", "self", ".", "namespace", ".", "prefix", ",", "prefix", ",", "id_", ")" ]

[ "Create", "an", "ID", "." ]

[ "def", "grayspec", "(", "k", ")", ":", "ll", "=", ".5", "ul", "=", ".8", "delta", "=", "(", "ul", "-", "ll", ")", "/", "k", "return", "[", "GrayScale", "(", "t", ")", "for", "t", "in", "np", ".", "arange", "(", "ll", ",", "ul", ",", "delta", ")", "]" ]

[ "List", "of", "gray", "-", "scale", "colors", "in", "HSV", "space", "as", "web", "hex", "triplets", "." ]

[ "def", "addrecords", "(", "X", ",", "new", ")", ":", "if", "isinstance", "(", "new", ",", "np", ".", "record", ")", "or", "isinstance", "(", "new", ",", "np", ".", "void", ")", "or", "isinstance", "(", "new", ",", "tuple", ")", ":", "new", "=", "[", "new", "]", "return", "np", ".", "append", "(", "X", ",", "utils", ".", "fromrecords", "(", "new", ",", "type", "=", "np", ".", "ndarray", ",", "dtype", "=", "X", ".", "dtype", ")", ",", "axis", "=", "0", ")" ]

[ "Append", "one", "or", "more", "records", "to", "the", "end", "of", "a", "numpy", "recarray", "or", "ndarray", "." ]

[ "def", "addcols", "(", "X", ",", "cols", ",", "names", "=", "None", ")", ":", "if", "isinstance", "(", "names", ",", "str", ")", ":", "names", "=", "[", "n", ".", "strip", "(", ")", "for", "n", "in", "names", ".", "split", "(", "','", ")", "]", "if", "isinstance", "(", "cols", ",", "list", ")", ":", "if", "any", "(", "[", "isinstance", "(", "x", ",", "np", ".", "ndarray", ")", "or", "isinstance", "(", "x", ",", "list", ")", "or", "isinstance", "(", "x", ",", "tuple", ")", "for", "x", "in", "cols", "]", ")", ":", "assert", "all", "(", "[", "len", "(", "x", ")", "==", "len", "(", "X", ")", "for", "x", "in", "cols", "]", ")", ",", "'Trying to add columns of wrong length.'", "assert", "names", "!=", "None", "and", "len", "(", "cols", ")", "==", "len", "(", "names", ")", ",", "'Number of columns to add must equal number of new names.'", "cols", "=", "utils", ".", "fromarrays", "(", "cols", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "names", ")", "else", ":", "assert", "len", "(", "cols", ")", "==", "len", "(", "X", ")", ",", "'Trying to add column of wrong length.'", "cols", "=", "utils", ".", "fromarrays", "(", "[", "cols", "]", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "names", ")", "else", ":", "assert", "isinstance", "(", "cols", ",", "np", ".", "ndarray", ")", "if", "cols", ".", "dtype", ".", "names", "==", "None", ":", "cols", "=", "utils", ".", "fromarrays", "(", "[", "cols", "]", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "names", ")", "Replacements", "=", "[", "a", "for", "a", "in", "cols", ".", "dtype", ".", "names", "if", "a", "in", "X", ".", "dtype", ".", "names", "]", "if", "len", "(", "Replacements", ")", ">", "0", ":", "print", "(", "'Replacing columns'", ",", "[", "a", "for", "a", "in", "cols", ".", "dtype", ".", "names", "if", "a", "in", "X", ".", "dtype", ".", "names", "]", ")", "return", "utils", ".", "fromarrays", "(", "[", "X", "[", "a", "]", "if", "a", "not", "in", "cols", ".", "dtype", ".", "names", "else", "cols", "[", "a", "]", "for", "a", "in", "X", ".", "dtype", ".", "names", "]", "+", "[", "cols", "[", "a", "]", "for", "a", "in", "cols", ".", "dtype", ".", "names", "if", "a", "not", "in", "X", ".", "dtype", ".", "names", "]", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "list", "(", "X", ".", "dtype", ".", "names", ")", "+", "[", "a", "for", "a", "in", "cols", ".", "dtype", ".", "names", "if", "a", "not", "in", "X", ".", "dtype", ".", "names", "]", ")" ]

[ "Add", "one", "or", "more", "columns", "to", "a", "numpy", "ndarray", "." ]

[ "def", "deletecols", "(", "X", ",", "cols", ")", ":", "if", "isinstance", "(", "cols", ",", "str", ")", ":", "cols", "=", "cols", ".", "split", "(", "','", ")", "retain", "=", "[", "n", "for", "n", "in", "X", ".", "dtype", ".", "names", "if", "n", "not", "in", "cols", "]", "if", "len", "(", "retain", ")", ">", "0", ":", "return", "X", "[", "retain", "]", "else", ":", "return", "None" ]

[ "Delete", "columns", "from", "a", "numpy", "ndarry", "or", "recarray", "." ]

[ "def", "renamecol", "(", "X", ",", "old", ",", "new", ")", ":", "NewNames", "=", "tuple", "(", "[", "n", "if", "n", "!=", "old", "else", "new", "for", "n", "in", "X", ".", "dtype", ".", "names", "]", ")", "X", ".", "dtype", ".", "names", "=", "NewNames" ]

[ "Rename", "column", "of", "a", "numpy", "ndarray", "with", "structured", "dtype", "in", "-", "place", "." ]

[ "def", "replace", "(", "X", ",", "old", ",", "new", ",", "strict", "=", "True", ",", "cols", "=", "None", ",", "rows", "=", "None", ")", ":", "if", "cols", "==", "None", ":", "cols", "=", "X", ".", "dtype", ".", "names", "elif", "isinstance", "(", "cols", ",", "str", ")", ":", "cols", "=", "cols", ".", "split", "(", "','", ")", "if", "rows", "==", "None", ":", "rows", "=", "np", ".", "ones", "(", "(", "len", "(", "X", ")", ",", ")", ",", "bool", ")", "if", "strict", ":", "new", "=", "np", ".", "array", "(", "new", ")", "for", "a", "in", "cols", ":", "if", "X", ".", "dtype", "[", "a", "]", "<", "new", ".", "dtype", ":", "print", "(", "'WARNING: dtype of column'", ",", "a", ",", "'is inferior to dtype of '", ",", "new", ",", "'which may cause problems.'", ")", "try", ":", "X", "[", "a", "]", "[", "(", "X", "[", "a", "]", "==", "old", ")", "[", "rows", "]", "]", "=", "new", "except", ":", "print", "(", "'Replacement not made on column'", ",", "a", ",", "'.'", ")", "else", ":", "for", "a", "in", "cols", ":", "QuickRep", "=", "True", "try", ":", "colstr", "=", "''", ".", "join", "(", "X", "[", "a", "]", "[", "rows", "]", ")", "except", "TypeError", ":", "print", "(", "'Not replacing in column'", ",", "a", ",", "'due to type mismatch.'", ")", "else", ":", "avoid", "=", "[", "ord", "(", "o", ")", "for", "o", "in", "utils", ".", "uniqify", "(", "old", "+", "new", "+", "colstr", ")", "]", "ok", "=", "set", "(", "range", "(", "256", ")", ")", ".", "difference", "(", "avoid", ")", "if", "len", "(", "ok", ")", ">", "0", ":", "sep", "=", "chr", "(", "list", "(", "ok", ")", "[", "0", "]", ")", "else", ":", "ok", "=", "set", "(", "range", "(", "65536", ")", ")", ".", "difference", "(", "avoid", ")", "if", "len", "(", "ok", ")", ">", "0", ":", "sep", "=", "unichr", "(", "list", "(", "ok", ")", "[", "0", "]", ")", "else", ":", "print", "(", "'All unicode characters represented in column'", ",", "a", ",", "', can\\t replace quickly.'", ")", "QuickRep", "=", "False", "if", "QuickRep", ":", "newrows", "=", "np", ".", "array", "(", "sep", ".", "join", "(", "X", "[", "a", "]", "[", "rows", "]", ")", ".", "replace", "(", "old", ",", "new", ")", ".", "split", "(", "sep", ")", ")", "else", ":", "newrows", "=", "np", ".", "array", "(", "[", "aa", ".", "replace", "(", "old", ",", "new", ")", "for", "aa", "in", "X", "[", "a", "]", "[", "rows", "]", "]", ")", "X", "[", "a", "]", "[", "rows", "]", "=", "np", ".", "cast", "[", "X", ".", "dtype", "[", "a", "]", "]", "(", "newrows", ")", "if", "newrows", ".", "dtype", ">", "X", ".", "dtype", "[", "a", "]", ":", "print", "(", "'WARNING: dtype of column'", ",", "a", ",", "'is inferior to the '", "'dtype of its replacement which may cause problems '", "'(ends of strings might get chopped off).'", ")" ]

[ "Replace", "value", "old", "with", "new", "everywhere", "it", "appears", "in", "-", "place", "." ]

[ "def", "rowstack", "(", "seq", ",", "mode", "=", "'nulls'", ",", "nullvals", "=", "None", ")", ":", "if", "nullvals", "==", "None", ":", "nullvals", "=", "utils", ".", "DEFAULT_NULLVALUEFORMAT", "#newseq = [ss for ss in seq if len(ss) > 0]", "if", "len", "(", "seq", ")", ">", "1", ":", "assert", "mode", "in", "[", "'commons'", ",", "'nulls'", ",", "'abort'", "]", ",", "(", "'\"mode\" argument must either by \"commons\", \"abort\", or \"nulls\".'", ")", "if", "mode", "==", "'abort'", ":", "if", "not", "all", "(", "[", "set", "(", "l", ".", "dtype", ".", "names", ")", "==", "set", "(", "seq", "[", "0", "]", ".", "dtype", ".", "names", ")", "for", "l", "in", "seq", "]", ")", ":", "raise", "ValueError", "(", "'Some column names are different.'", ")", "else", ":", "mode", "=", "'commons'", "if", "mode", "==", "'nulls'", ":", "names", "=", "utils", ".", "uniqify", "(", "utils", ".", "listunion", "(", "[", "list", "(", "s", ".", "dtype", ".", "names", ")", "for", "s", "in", "seq", "if", "s", ".", "dtype", ".", "names", "!=", "None", "]", ")", ")", "formats", "=", "[", "max", "(", "[", "s", ".", "dtype", "[", "att", "]", "for", "s", "in", "seq", "if", "s", ".", "dtype", ".", "names", "!=", "None", "and", "att", "in", "s", ".", "dtype", ".", "names", "]", ")", ".", "str", "for", "att", "in", "names", "]", "dtype", "=", "np", ".", "dtype", "(", "zip", "(", "names", ",", "formats", ")", ")", "return", "utils", ".", "fromarrays", "(", "[", "utils", ".", "listunion", "(", "[", "s", "[", "att", "]", ".", "tolist", "(", ")", "if", "(", "s", ".", "dtype", ".", "names", "!=", "None", "and", "att", "in", "s", ".", "dtype", ".", "names", ")", "else", "[", "nullvals", "(", "format", ")", "]", "*", "len", "(", "s", ")", "for", "s", "in", "seq", "]", ")", "for", "(", "att", ",", "format", ")", "in", "zip", "(", "names", ",", "formats", ")", "]", ",", "type", "=", "np", ".", "ndarray", ",", "dtype", "=", "dtype", ")", "elif", "mode", "==", "'commons'", ":", "names", "=", "[", "x", "for", "x", "in", "seq", "[", "0", "]", ".", "dtype", ".", "names", "if", "all", "(", "[", "x", "in", "l", ".", "dtype", ".", "names", "for", "l", "in", "seq", "[", "1", ":", "]", "]", ")", "]", "formats", "=", "[", "max", "(", "[", "a", ".", "dtype", "[", "att", "]", "for", "a", "in", "seq", "]", ")", ".", "str", "for", "att", "in", "names", "]", "return", "utils", ".", "fromrecords", "(", "utils", ".", "listunion", "(", "[", "ar", ".", "tolist", "(", ")", "for", "ar", "in", "seq", "]", ")", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "names", ",", "formats", "=", "formats", ")", "else", ":", "return", "seq", "[", "0", "]" ]

[ "Vertically", "stack", "a", "sequence", "of", "numpy", "ndarrays", "with", "structured", "dtype" ]

[ "def", "colstack", "(", "seq", ",", "mode", "=", "'abort'", ",", "returnnaming", "=", "False", ")", ":", "assert", "mode", "in", "[", "'first'", ",", "'drop'", ",", "'abort'", ",", "'rename'", "]", ",", "'mode argument must take on value \"first\",\"drop\", \"rename\", or \"abort\".'", "AllNames", "=", "utils", ".", "uniqify", "(", "utils", ".", "listunion", "(", "[", "list", "(", "l", ".", "dtype", ".", "names", ")", "for", "l", "in", "seq", "]", ")", ")", "NameList", "=", "[", "(", "x", ",", "[", "i", "for", "i", "in", "range", "(", "len", "(", "seq", ")", ")", "if", "x", "in", "seq", "[", "i", "]", ".", "dtype", ".", "names", "]", ")", "for", "x", "in", "AllNames", "]", "Commons", "=", "[", "x", "[", "0", "]", "for", "x", "in", "NameList", "if", "len", "(", "x", "[", "1", "]", ")", ">", "1", "]", "if", "len", "(", "Commons", ")", ">", "0", "or", "mode", "==", "'first'", ":", "if", "mode", "==", "'abort'", ":", "raise", "ValueError", "(", "'There are common column names with differing '", "+", "'values in the columns'", ")", "elif", "mode", "==", "'drop'", ":", "Names", "=", "[", "(", "L", "[", "0", "]", ",", "x", ",", "x", ")", "for", "(", "x", ",", "L", ")", "in", "NameList", "if", "x", "not", "in", "Commons", "]", "elif", "mode", "==", "'rename'", ":", "NameDict", "=", "dict", "(", "NameList", ")", "Names", "=", "utils", ".", "listunion", "(", "[", "[", "(", "i", ",", "n", ",", "n", ")", "if", "len", "(", "NameDict", "[", "n", "]", ")", "==", "1", "else", "(", "i", ",", "n", ",", "n", "+", "'_'", "+", "str", "(", "i", ")", ")", "for", "n", "in", "s", ".", "dtype", ".", "names", "]", "for", "(", "i", ",", "s", ")", "in", "enumerate", "(", "seq", ")", "]", ")", "else", ":", "Names", "=", "[", "(", "L", "[", "0", "]", ",", "x", ",", "x", ")", "for", "(", "x", ",", "L", ")", "in", "NameList", "]", "if", "returnnaming", ":", "return", "utils", ".", "fromarrays", "(", "[", "seq", "[", "i", "]", "[", "x", "]", "for", "(", "i", ",", "x", ",", "y", ")", "in", "Names", "]", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "zip", "(", "*", "Names", ")", "[", "2", "]", ")", ",", "Names", "else", ":", "return", "utils", ".", "fromarrays", "(", "[", "seq", "[", "i", "]", "[", "x", "]", "for", "(", "i", ",", "x", ",", "y", ")", "in", "Names", "]", ",", "type", "=", "np", ".", "ndarray", ",", "names", "=", "zip", "(", "*", "Names", ")", "[", "2", "]", ")" ]

[ "Horizontally", "stack", "a", "sequence", "of", "numpy", "ndarrays", "with", "structured", "dtypes" ]

[ "def", "DEFAULT_RENAMER", "(", "L", ",", "Names", "=", "None", ")", ":", "if", "isinstance", "(", "L", ",", "dict", ")", ":", "Names", "=", "L", ".", "keys", "(", ")", "LL", "=", "L", ".", "values", "(", ")", "else", ":", "if", "Names", "==", "None", ":", "Names", "=", "range", "(", "len", "(", "L", ")", ")", "else", ":", "assert", "len", "(", "Names", ")", "==", "len", "(", "L", ")", "LL", "=", "L", "commons", "=", "Commons", "(", "[", "l", ".", "dtype", ".", "names", "for", "l", "in", "LL", "]", ")", "D", "=", "{", "}", "for", "(", "i", ",", "l", ")", "in", "zip", "(", "Names", ",", "LL", ")", ":", "d", "=", "{", "}", "for", "c", "in", "commons", ":", "if", "c", "in", "l", ".", "dtype", ".", "names", ":", "d", "[", "c", "]", "=", "c", "+", "'_'", "+", "str", "(", "i", ")", "if", "d", ":", "D", "[", "i", "]", "=", "d", "return", "D" ]

[ "Renames", "overlapping", "column", "names", "of", "numpy", "ndarrays", "with", "structured", "dtypes" ]

[ "def", "getjp2image", "(", "date", ",", "sourceId", "=", "None", ",", "observatory", "=", "None", ",", "instrument", "=", "None", ",", "detector", "=", "None", ",", "measurement", "=", "None", ")", ":", "base_url", "=", "'http://helioviewer.org/api/v1/getJP2Image/?'", "req_url", "=", "''", "try", ":", "validate_iso8601", "(", "date", ")", "if", "not", "date", "[", "-", "1", ":", "]", "==", "'Z'", ":", "date", "+=", "'Z'", "base_url", "+=", "'date='", "+", "date", "except", ":", "raise", "ValueError", "(", "\"Your date input is not in iso8601 format. ex: 2014-01-01T23:59:59\"", ")", "if", "sourceId", ":", "if", "not", "isinstance", "(", "sourceId", ",", "int", ")", ":", "logger", ".", "error", "(", "\"The sourceId argument should be an int, ignoring it\"", ")", "else", ":", "base_url", "+=", "\"sourceId=\"", "+", "str", "(", "sourceId", ")", "+", "\"&\"", "if", "observatory", ":", "if", "not", "isinstance", "(", "observatory", ",", "str", ")", ":", "logger", ".", "error", "(", "\"The observatory argument should be a str, ignoring it\"", ")", "else", ":", "base_url", "+=", "\"observatory=\"", "+", "observatory", "+", "\"&\"", "if", "instrument", ":", "if", "not", "isinstance", "(", "instrument", ",", "str", ")", ":", "logger", ".", "error", "(", "\"The instrument argument should be a str, ignoring it\"", ")", "else", ":", "base_url", "+=", "\"instrument=\"", "+", "instrument", "+", "\"&\"", "if", "detector", ":", "if", "not", "isinstance", "(", "detector", ",", "str", ")", ":", "logger", ".", "error", "(", "\"The detector argument should be a str, ignoring it\"", ")", "else", ":", "base_url", "+=", "\"detector=\"", "+", "detector", "+", "\"&\"", "if", "measurement", ":", "if", "not", "isinstance", "(", "measurement", ",", "str", ")", ":", "logger", ".", "error", "(", "\"The measurement argument should be a str, ignoring it\"", ")", "else", ":", "base_url", "+=", "\"measurement=\"", "+", "detector", "+", "\"&\"", "req_url", "+=", "base_url", "+", "\"jpip=true\"", "return", "dispatch_http_get", "(", "req_url", ")" ]

[ "Helioviewer", ".", "org", "and", "JHelioviewer", "operate", "off", "of", "JPEG2000", "formatted", "image", "data", "generated", "from", "science", "-", "quality", "FITS", "files", ".", "Use", "the", "APIs", "below", "to", "interact", "directly", "with", "these", "intermediary", "JPEG2000", "files", ".", "Download", "a", "JP2", "image", "for", "the", "specified", "datasource", "that", "is", "the", "closest", "match", "in", "time", "to", "the", "date", "requested", "." ]

[ "def", "loads_loader", "(", "load_module", ":", "types", ".", "ModuleType", ",", "pairs", ":", "Dict", "[", "str", ",", "str", "]", ")", "->", "Optional", "[", "JSGValidateable", "]", ":", "cntxt", "=", "load_module", ".", "_CONTEXT", "# If the type element is a member of the JSON, load it", "possible_type", "=", "pairs", "[", "cntxt", ".", "TYPE", "]", "if", "cntxt", ".", "TYPE", "in", "pairs", "else", "None", "target_class", "=", "getattr", "(", "load_module", ",", "possible_type", ",", "None", ")", "if", "isinstance", "(", "possible_type", ",", "str", ")", "else", "None", "if", "target_class", ":", "return", "target_class", "(", "*", "*", "pairs", ")", "# See whether there are any exception types that are valid for the incoming data", "for", "type_exception", "in", "cntxt", ".", "TYPE_EXCEPTIONS", ":", "if", "not", "hasattr", "(", "load_module", ",", "type_exception", ")", ":", "raise", "ValueError", "(", "UNKNOWN_TYPE_EXCEPTION", ".", "format", "(", "type_exception", ")", ")", "target_class", "=", "getattr", "(", "load_module", ",", "type_exception", ")", "target_strict", "=", "target_class", ".", "_strict", "target_class", ".", "_strict", "=", "False", "try", ":", "rval", "=", "target_class", "(", "*", "*", "pairs", ")", "finally", ":", "target_class", ".", "_strict", "=", "target_strict", "if", "is_valid", "(", "rval", ")", ":", "return", "rval", "# If there is not a type variable and nothing fits, just load up the first (and perhaps only) exception", "# It will later fail any is_valid tests", "if", "not", "cntxt", ".", "TYPE", "and", "cntxt", ".", "TYPE_EXCEPTIONS", ":", "return", "getattr", "(", "load_module", ",", "cntxt", ".", "TYPE_EXCEPTIONS", "[", "0", "]", ")", "(", "*", "*", "pairs", ")", "if", "cntxt", ".", "TYPE", "in", "pairs", ":", "raise", "ValueError", "(", "f'Unknown reference type: \"{cntxt.TYPE}\": \"{pairs[cntxt.TYPE]}\"'", ")", "else", ":", "raise", "ValueError", "(", "f'Missing \"{cntxt.TYPE}\" element'", ")" ]

[ "json", "loader", "objecthook" ]

[ "def", "loads", "(", "s", ":", "str", ",", "load_module", ":", "types", ".", "ModuleType", ",", "*", "*", "kwargs", ")", ":", "return", "json", ".", "loads", "(", "s", ",", "object_hook", "=", "lambda", "pairs", ":", "loads_loader", "(", "load_module", ",", "pairs", ")", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "a", "JSON", "string", "into", "a", "JSGObject" ]

[ "def", "load", "(", "fp", ":", "Union", "[", "TextIO", ",", "str", "]", ",", "load_module", ":", "types", ".", "ModuleType", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "fp", ",", "str", ")", ":", "with", "open", "(", "fp", ")", "as", "f", ":", "return", "loads", "(", "f", ".", "read", "(", ")", ",", "load_module", ",", "*", "*", "kwargs", ")", "else", ":", "return", "loads", "(", "fp", ".", "read", "(", ")", ",", "load_module", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "a", "file", "name", "or", "file", "-", "like", "object", "containing", "stringified", "JSON", "into", "a", "JSGObject" ]

[ "def", "isinstance_", "(", "x", ",", "A_tuple", ")", ":", "if", "is_union", "(", "A_tuple", ")", ":", "return", "any", "(", "isinstance_", "(", "x", ",", "t", ")", "for", "t", "in", "A_tuple", ".", "__args__", ")", "elif", "getattr", "(", "A_tuple", ",", "'__origin__'", ",", "None", ")", "is", "not", "None", ":", "return", "isinstance", "(", "x", ",", "A_tuple", ".", "__origin__", ")", "else", ":", "return", "isinstance", "(", "x", ",", "A_tuple", ")" ]

[ "native", "isinstance_", "with", "the", "test", "for", "typing", ".", "Union", "overridden" ]

[ "def", "is_valid", "(", "obj", ":", "JSGValidateable", ",", "log", ":", "Optional", "[", "Union", "[", "TextIO", ",", "Logger", "]", "]", "=", "None", ")", "->", "bool", ":", "return", "obj", ".", "_is_valid", "(", "log", ")" ]

[ "Determine", "whether", "obj", "is", "valid" ]

[ "def", "arg_tup_to_dict", "(", "argument_tuples", ")", ":", "data", "=", "dict", "(", ")", "for", "arg_name", ",", "arg_val", "in", "argument_tuples", ":", "if", "arg_val", "is", "not", "None", ":", "if", "arg_val", "is", "True", ":", "arg_val", "=", "'true'", "elif", "arg_val", "is", "False", ":", "arg_val", "=", "'false'", "data", "[", "arg_name", "]", "=", "arg_val", "return", "data" ]

[ "Given", "a", "set", "of", "argument", "tuples", "set", "their", "value", "in", "a", "data", "dictionary", "if", "not", "blank" ]

[ "def", "handle_error", "(", "response", ")", ":", "status_code", "=", "response", ".", "status_code", "if", "status_code", "not", "in", "A_OK_HTTP_CODES", ":", "error_explanation", "=", "A_ERROR_HTTP_CODES", ".", "get", "(", "status_code", ")", "raise_error", "=", "\"{}: {}\"", ".", "format", "(", "status_code", ",", "error_explanation", ")", "raise", "Exception", "(", "raise_error", ")", "else", ":", "return", "True" ]

[ "Raise", "appropriate", "exceptions", "if", "necessary", "." ]

[ "async", "def", "open", "(", "self", ")", "->", "'_BaseAgent'", ":", "LOGGER", ".", "debug", "(", "'_BaseAgent.open >>>'", ")", "# Do not open pool independently: let relying party decide when to go on-line and off-line", "await", "self", ".", "wallet", ".", "open", "(", ")", "LOGGER", ".", "debug", "(", "'_BaseAgent.open <<<'", ")", "return", "self" ]

[ "Context", "manager", "entry", ";", "open", "wallet", ".", "For", "use", "when", "keeping", "agent", "open", "across", "multiple", "calls", "." ]

[ "async", "def", "_get_rev_reg_def", "(", "self", ",", "rr_id", ":", "str", ")", "->", "str", ":", "LOGGER", ".", "debug", "(", "'_BaseAgent._get_rev_reg_def >>> rr_id: %s'", ",", "rr_id", ")", "rv_json", "=", "json", ".", "dumps", "(", "{", "}", ")", "with", "REVO_CACHE", ".", "lock", ":", "revo_cache_entry", "=", "REVO_CACHE", ".", "get", "(", "rr_id", ",", "None", ")", "rr_def", "=", "revo_cache_entry", ".", "rev_reg_def", "if", "revo_cache_entry", "else", "None", "if", "rr_def", ":", "LOGGER", ".", "info", "(", "'_BaseAgent._get_rev_reg_def: rev reg def for %s from cache'", ",", "rr_id", ")", "rv_json", "=", "json", ".", "dumps", "(", "rr_def", ")", "else", ":", "get_rrd_req_json", "=", "await", "ledger", ".", "build_get_revoc_reg_def_request", "(", "self", ".", "did", ",", "rr_id", ")", "resp_json", "=", "await", "self", ".", "_submit", "(", "get_rrd_req_json", ")", "try", ":", "(", "_", ",", "rv_json", ")", "=", "await", "ledger", ".", "parse_get_revoc_reg_def_response", "(", "resp_json", ")", "rr_def", "=", "json", ".", "loads", "(", "rv_json", ")", "except", "IndyError", ":", "# ledger replied, but there is no such rev reg", "LOGGER", ".", "debug", "(", "'_BaseAgent._get_rev_reg_def: <!< no rev reg exists on %s'", ",", "rr_id", ")", "raise", "AbsentRevReg", "(", "'No rev reg exists on {}'", ".", "format", "(", "rr_id", ")", ")", "if", "revo_cache_entry", "is", "None", ":", "REVO_CACHE", "[", "rr_id", "]", "=", "RevoCacheEntry", "(", "rr_def", ",", "None", ")", "else", ":", "REVO_CACHE", "[", "rr_id", "]", ".", "rev_reg_def", "=", "rr_def", "LOGGER", ".", "debug", "(", "'_BaseAgent._get_rev_reg_def <<< %s'", ",", "rv_json", ")", "return", "rv_json" ]

[ "Get", "revocation", "registry", "definition", "from", "ledger", "by", "its", "identifier", ".", "Raise", "AbsentRevReg", "for", "no", "such", "revocation", "registry", "logging", "any", "error", "condition", "and", "raising", "BadLedgerTxn", "on", "bad", "request", "." ]

[ "async", "def", "get_cred_def", "(", "self", ",", "cd_id", ":", "str", ")", "->", "str", ":", "LOGGER", ".", "debug", "(", "'_BaseAgent.get_cred_def >>> cd_id: %s'", ",", "cd_id", ")", "rv_json", "=", "json", ".", "dumps", "(", "{", "}", ")", "with", "CRED_DEF_CACHE", ".", "lock", ":", "if", "cd_id", "in", "CRED_DEF_CACHE", ":", "LOGGER", ".", "info", "(", "'_BaseAgent.get_cred_def: got cred def for %s from cache'", ",", "cd_id", ")", "rv_json", "=", "json", ".", "dumps", "(", "CRED_DEF_CACHE", "[", "cd_id", "]", ")", "LOGGER", ".", "debug", "(", "'_BaseAgent.get_cred_def <<< %s'", ",", "rv_json", ")", "return", "rv_json", "req_json", "=", "await", "ledger", ".", "build_get_cred_def_request", "(", "self", ".", "did", ",", "cd_id", ")", "resp_json", "=", "await", "self", ".", "_submit", "(", "req_json", ")", "resp", "=", "json", ".", "loads", "(", "resp_json", ")", "if", "not", "(", "'result'", "in", "resp", "and", "resp", "[", "'result'", "]", ".", "get", "(", "'data'", ",", "None", ")", ")", ":", "LOGGER", ".", "debug", "(", "'_BaseAgent.get_cred_def: <!< no cred def exists on %s'", ",", "cd_id", ")", "raise", "AbsentCredDef", "(", "'No cred def exists on {}'", ".", "format", "(", "cd_id", ")", ")", "try", ":", "(", "_", ",", "rv_json", ")", "=", "await", "ledger", ".", "parse_get_cred_def_response", "(", "resp_json", ")", "except", "IndyError", ":", "# ledger replied, but there is no such cred def", "LOGGER", ".", "debug", "(", "'_BaseAgent.get_cred_def: <!< no cred def exists on %s'", ",", "cd_id", ")", "raise", "AbsentCredDef", "(", "'No cred def exists on {}'", ".", "format", "(", "cd_id", ")", ")", "CRED_DEF_CACHE", "[", "cd_id", "]", "=", "json", ".", "loads", "(", "rv_json", ")", "LOGGER", ".", "info", "(", "'_BaseAgent.get_cred_def: got cred def %s from ledger'", ",", "cd_id", ")", "LOGGER", ".", "debug", "(", "'_BaseAgent.get_cred_def <<< %s'", ",", "rv_json", ")", "return", "rv_json" ]

[ "Get", "credential", "definition", "from", "ledger", "by", "its", "identifier", "." ]

[ "def", "is_union", "(", "etype", ")", "->", "bool", ":", "return", "getattr", "(", "etype", ",", "'__origin__'", ",", "None", ")", "is", "not", "None", "and", "getattr", "(", "etype", ".", "__origin__", ",", "'_name'", ",", "None", ")", "and", "etype", ".", "__origin__", ".", "_name", "==", "'Union'" ]

[ "Determine", "whether", "etype", "is", "a", "Union" ]

[ "def", "unset", "(", "entity", ",", "*", "types", ")", ":", "if", "not", "types", ":", "types", "=", "(", "TypedField", ",", ")", "fields", "=", "list", "(", "entity", ".", "_fields", ".", "keys", "(", ")", ")", "remove", "=", "(", "x", "for", "x", "in", "fields", "if", "isinstance", "(", "x", ",", "types", ")", ")", "for", "field", "in", "remove", ":", "del", "entity", ".", "_fields", "[", "field", "]" ]

[ "Unset", "the", "TypedFields", "on", "the", "input", "entity", "." ]

[ "def", "_matches", "(", "field", ",", "params", ")", ":", "fieldattrs", "=", "six", ".", "iteritems", "(", "params", ")", "return", "all", "(", "getattr", "(", "field", ",", "attr", ")", "==", "val", "for", "attr", ",", "val", "in", "fieldattrs", ")" ]

[ "Return", "True", "if", "the", "input", "TypedField", "field", "contains", "instance", "attributes", "that", "match", "the", "input", "parameters", "." ]

[ "def", "iterfields", "(", "klass", ")", ":", "is_field", "=", "lambda", "x", ":", "isinstance", "(", "x", ",", "TypedField", ")", "for", "name", ",", "field", "in", "inspect", ".", "getmembers", "(", "klass", ",", "predicate", "=", "is_field", ")", ":", "yield", "name", ",", "field" ]

[ "Iterate", "over", "the", "input", "class", "members", "and", "yield", "its", "TypedFields", "." ]

[ "def", "_clean", "(", "self", ",", "value", ")", ":", "if", "value", "is", "None", ":", "return", "None", "elif", "self", ".", "type_", "is", "None", ":", "return", "value", "elif", "self", ".", "check_type", "(", "value", ")", ":", "return", "value", "elif", "self", ".", "is_type_castable", ":", "# noqa", "return", "self", ".", "type_", "(", "value", ")", "error_fmt", "=", "\"%s must be a %s, not a %s\"", "error", "=", "error_fmt", "%", "(", "self", ".", "name", ",", "self", ".", "type_", ",", "type", "(", "value", ")", ")", "raise", "TypeError", "(", "error", ")" ]

[ "Validate", "and", "clean", "a", "candidate", "value", "for", "this", "field", "." ]

[ "def", "remove_collection", "(", "self", ",", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "=", "None", ",", "commit_msg", "=", "None", ")", ":", "if", "fourth_arg", "is", "None", ":", "collection_id", ",", "branch_name", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", "gh_user", "=", "branch_name", ".", "split", "(", "'_collection_'", ")", "[", "0", "]", "parent_sha", "=", "self", ".", "get_master_sha", "(", ")", "else", ":", "gh_user", ",", "collection_id", ",", "parent_sha", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "if", "commit_msg", "is", "None", ":", "commit_msg", "=", "\"Delete Collection '%s' via OpenTree API\"", "%", "collection_id", "return", "self", ".", "_remove_document", "(", "gh_user", ",", "collection_id", ",", "parent_sha", ",", "author", ",", "commit_msg", ")" ]

[ "Remove", "a", "collection", "Given", "a", "collection_id", "branch", "and", "optionally", "an", "author", "remove", "a", "collection", "on", "the", "given", "branch", "and", "attribute", "the", "commit", "to", "author", ".", "Returns", "the", "SHA", "of", "the", "commit", "on", "branch", "." ]

[ "async", "def", "load_cache", "(", "self", ",", "archive", ":", "bool", "=", "False", ")", "->", "int", ":", "LOGGER", ".", "debug", "(", "'Verifier.load_cache >>> archive: %s'", ",", "archive", ")", "rv", "=", "int", "(", "time", "(", ")", ")", "for", "s_id", "in", "self", ".", "cfg", ".", "get", "(", "'archive-on-close'", ",", "{", "}", ")", ".", "get", "(", "'schema_id'", ",", "{", "}", ")", ":", "with", "SCHEMA_CACHE", ".", "lock", ":", "await", "self", ".", "get_schema", "(", "s_id", ")", "for", "cd_id", "in", "self", ".", "cfg", ".", "get", "(", "'archive-on-close'", ",", "{", "}", ")", ".", "get", "(", "'cred_def_id'", ",", "{", "}", ")", ":", "with", "CRED_DEF_CACHE", ".", "lock", ":", "await", "self", ".", "get_cred_def", "(", "cd_id", ")", "for", "rr_id", "in", "self", ".", "cfg", ".", "get", "(", "'archive-on-close'", ",", "{", "}", ")", ".", "get", "(", "'rev_reg_id'", ",", "{", "}", ")", ":", "await", "self", ".", "_get_rev_reg_def", "(", "rr_id", ")", "with", "REVO_CACHE", ".", "lock", ":", "revo_cache_entry", "=", "REVO_CACHE", ".", "get", "(", "rr_id", ",", "None", ")", "if", "revo_cache_entry", ":", "try", ":", "await", "revo_cache_entry", ".", "get_state_json", "(", "self", ".", "_build_rr_state_json", ",", "rv", ",", "rv", ")", "except", "ClosedPool", ":", "LOGGER", ".", "warning", "(", "'Verifier %s is offline from pool %s, cannot update revo cache reg state for %s to %s'", ",", "self", ".", "wallet", ".", "name", ",", "self", ".", "pool", ".", "name", ",", "rr_id", ",", "rv", ")", "if", "archive", ":", "Caches", ".", "archive", "(", "self", ".", "dir_cache", ")", "LOGGER", ".", "debug", "(", "'Verifier.load_cache <<< %s'", ",", "rv", ")", "return", "rv" ]

[ "Load", "caches", "and", "archive", "enough", "to", "go", "offline", "and", "be", "able", "to", "verify", "proof", "on", "content", "marked", "of", "interest", "in", "configuration", "." ]

[ "def", "can", "(", "self", ")", ":", "return", "str", "(", "current_user", ".", "get_id", "(", ")", ")", "==", "str", "(", "self", ".", "community", ".", "id_user", ")", "or", "DynamicPermission", "(", "ActionNeed", "(", "'admin-access'", ")", ")", ".", "can", "(", ")" ]

[ "Grant", "permission", "if", "owner", "or", "admin", "." ]

[ "def", "listunion", "(", "ListOfLists", ")", ":", "u", "=", "[", "]", "for", "s", "in", "ListOfLists", ":", "if", "s", "!=", "None", ":", "u", ".", "extend", "(", "s", ")", "return", "u" ]

[ "Take", "the", "union", "of", "a", "list", "of", "lists", "." ]

[ "def", "DEFAULT_NULLVALUE", "(", "test", ")", ":", "return", "False", "if", "isinstance", "(", "test", ",", "bool", ")", "else", "0", "if", "isinstance", "(", "test", ",", "int", ")", "else", "0.0", "if", "isinstance", "(", "test", ",", "float", ")", "else", "''" ]

[ "Returns", "a", "null", "value", "for", "each", "of", "various", "kinds", "of", "test", "values", "." ]

[ "def", "as_python", "(", "self", ",", "name", ":", "str", ")", "->", "str", ":", "if", "self", ".", "_map_valuetype", ":", "return", "self", ".", "map_as_python", "(", "name", ")", "else", ":", "return", "self", ".", "obj_as_python", "(", "name", ")" ]

[ "Return", "the", "python", "representation", "of", "the", "class", "represented", "by", "this", "object" ]

[ "def", "members_entries", "(", "self", ",", "all_are_optional", ":", "bool", "=", "False", ")", "->", "List", "[", "Tuple", "[", "str", ",", "str", "]", "]", ":", "rval", "=", "[", "]", "if", "self", ".", "_members", ":", "for", "member", "in", "self", ".", "_members", ":", "rval", "+=", "member", ".", "members_entries", "(", "all_are_optional", ")", "elif", "self", ".", "_choices", ":", "for", "choice", "in", "self", ".", "_choices", ":", "rval", "+=", "self", ".", "_context", ".", "reference", "(", "choice", ")", ".", "members_entries", "(", "True", ")", "else", ":", "return", "[", "]", "return", "rval" ]

[ "Return", "an", "ordered", "list", "of", "elements", "for", "the", "_members", "section" ]

[ "def", "_get_filtered_study_ids", "(", "shard", ",", "include_aliases", "=", "False", ")", ":", "from", "peyotl", ".", "phylesystem", ".", "helper", "import", "DIGIT_PATTERN", "k", "=", "shard", ".", "get_doc_ids", "(", ")", "if", "shard", ".", "has_aliases", "and", "(", "not", "include_aliases", ")", ":", "x", "=", "[", "]", "for", "i", "in", "k", ":", "if", "DIGIT_PATTERN", ".", "match", "(", "i", ")", "or", "(", "(", "len", "(", "i", ")", ">", "1", ")", "and", "(", "i", "[", "-", "2", "]", "==", "'_'", ")", ")", ":", "pass", "else", ":", "x", ".", "append", "(", "i", ")", "return", "x" ]

[ "Optionally", "filters", "out", "aliases", "from", "standard", "doc", "-", "id", "list" ]

[ "def", "_determine_next_study_id", "(", "self", ")", ":", "if", "self", ".", "_doc_counter_lock", "is", "None", ":", "self", ".", "_doc_counter_lock", "=", "Lock", "(", ")", "prefix", "=", "self", ".", "_new_study_prefix", "lp", "=", "len", "(", "prefix", ")", "n", "=", "0", "# this function holds the lock for quite awhile,", "# but it only called on the first instance of", "# of creating a new study", "with", "self", ".", "_doc_counter_lock", ":", "with", "self", ".", "_index_lock", ":", "for", "k", "in", "self", ".", "study_index", ".", "keys", "(", ")", ":", "if", "k", ".", "startswith", "(", "prefix", ")", ":", "try", ":", "pn", "=", "int", "(", "k", "[", "lp", ":", "]", ")", "if", "pn", ">", "n", ":", "n", "=", "pn", "except", ":", "pass", "nsi_contents", "=", "self", ".", "_read_master_branch_resource", "(", "self", ".", "_id_minting_file", ",", "is_json", "=", "True", ")", "if", "nsi_contents", ":", "self", ".", "_next_study_id", "=", "nsi_contents", "[", "'next_study_id'", "]", "if", "self", ".", "_next_study_id", "<=", "n", ":", "m", "=", "'next_study_id in {} is set lower than the ID of an existing study!'", "m", "=", "m", ".", "format", "(", "self", ".", "_id_minting_file", ")", "raise", "RuntimeError", "(", "m", ")", "else", ":", "# legacy support for repo with no next_study_id.json file", "self", ".", "_next_study_id", "=", "n", "self", ".", "_advance_new_study_id", "(", ")" ]

[ "Return", "the", "numeric", "part", "of", "the", "newest", "study_id" ]

[ "def", "_advance_new_study_id", "(", "self", ")", ":", "c", "=", "self", ".", "_next_study_id", "self", ".", "_next_study_id", "=", "1", "+", "c", "content", "=", "u'{\"next_study_id\": %d}\\n'", "%", "self", ".", "_next_study_id", "# The content is JSON, but we hand-rolled the string above", "# so that we can use it as a commit_msg", "self", ".", "_write_master_branch_resource", "(", "content", ",", "self", ".", "_id_minting_file", ",", "commit_msg", "=", "content", ",", "is_json", "=", "False", ")", "return", "c" ]

[ "ASSUMES", "the", "caller", "holds", "the", "_doc_counter_lock", "!", "Returns", "the", "current", "numeric", "part", "of", "the", "next", "study", "ID", "advances", "the", "counter", "to", "the", "next", "value", "and", "stores", "that", "value", "in", "the", "file", "in", "case", "the", "server", "is", "restarted", "." ]

[ "def", "flatten", "(", "l", ":", "Iterable", ")", "->", "List", ":", "rval", "=", "[", "]", "for", "e", "in", "l", ":", "if", "not", "isinstance", "(", "e", ",", "str", ")", "and", "isinstance", "(", "e", ",", "Iterable", ")", ":", "if", "len", "(", "list", "(", "e", ")", ")", ":", "rval", "+=", "flatten", "(", "e", ")", "else", ":", "rval", ".", "append", "(", "e", ")", "return", "rval" ]

[ "Return", "a", "list", "of", "all", "non", "-", "list", "items", "in", "l" ]

[ "def", "flatten_unique", "(", "l", ":", "Iterable", ")", "->", "List", ":", "rval", "=", "OrderedDict", "(", ")", "for", "e", "in", "l", ":", "if", "not", "isinstance", "(", "e", ",", "str", ")", "and", "isinstance", "(", "e", ",", "Iterable", ")", ":", "for", "ev", "in", "flatten_unique", "(", "e", ")", ":", "rval", "[", "ev", "]", "=", "None", "else", ":", "rval", "[", "e", "]", "=", "None", "return", "list", "(", "rval", ".", "keys", "(", ")", ")" ]

[ "Return", "a", "list", "of", "UNIQUE", "non", "-", "list", "items", "in", "l" ]

[ "def", "as_tokens", "(", "ctx", ":", "List", "[", "ParserRuleContext", "]", ")", "->", "List", "[", "str", "]", ":", "return", "[", "as_token", "(", "e", ")", "for", "e", "in", "ctx", "]" ]

[ "Return", "a", "stringified", "list", "of", "identifiers", "in", "ctx" ]

[ "def", "is_valid_python", "(", "tkn", ":", "str", ")", "->", "bool", ":", "try", ":", "root", "=", "ast", ".", "parse", "(", "tkn", ")", "except", "SyntaxError", ":", "return", "False", "return", "len", "(", "root", ".", "body", ")", "==", "1", "and", "isinstance", "(", "root", ".", "body", "[", "0", "]", ",", "ast", ".", "Expr", ")", "and", "isinstance", "(", "root", ".", "body", "[", "0", "]", ".", "value", ",", "ast", ".", "Name", ")" ]

[ "Determine", "whether", "tkn", "is", "a", "valid", "python", "identifier" ]

[ "def", "remove_study", "(", "self", ",", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "=", "None", ",", "commit_msg", "=", "None", ")", ":", "if", "fourth_arg", "is", "None", ":", "study_id", ",", "branch_name", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", "gh_user", "=", "branch_name", ".", "split", "(", "'_study_'", ")", "[", "0", "]", "parent_sha", "=", "self", ".", "get_master_sha", "(", ")", "else", ":", "gh_user", ",", "study_id", ",", "parent_sha", ",", "author", "=", "first_arg", ",", "sec_arg", ",", "third_arg", ",", "fourth_arg", "if", "commit_msg", "is", "None", ":", "commit_msg", "=", "\"Delete Study #%s via OpenTree API\"", "%", "study_id", "return", "self", ".", "_remove_document", "(", "gh_user", ",", "study_id", ",", "parent_sha", ",", "author", ",", "commit_msg", ")" ]

[ "Remove", "a", "study", "Given", "a", "study_id", "branch", "and", "optionally", "an", "author", "remove", "a", "study", "on", "the", "given", "branch", "and", "attribute", "the", "commit", "to", "author", ".", "Returns", "the", "SHA", "of", "the", "commit", "on", "branch", "." ]

[ "def", "init", "(", ")", ":", "try", ":", "initialize_communities_bucket", "(", ")", "click", ".", "secho", "(", "'Community init successful.'", ",", "fg", "=", "'green'", ")", "except", "FilesException", "as", "e", ":", "click", ".", "secho", "(", "e", ".", "message", ",", "fg", "=", "'red'", ")" ]

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

[ "def", "addlogo", "(", "community_id", ",", "logo", ")", ":", "# Create the bucket", "c", "=", "Community", ".", "get", "(", "community_id", ")", "if", "not", "c", ":", "click", ".", "secho", "(", "'Community {0} does not exist.'", ".", "format", "(", "community_id", ")", ",", "fg", "=", "'red'", ")", "return", "ext", "=", "save_and_validate_logo", "(", "logo", ",", "logo", ".", "name", ",", "c", ".", "id", ")", "c", ".", "logo_ext", "=", "ext", "db", ".", "session", ".", "commit", "(", ")" ]

[ "Add", "logo", "to", "the", "community", "." ]

[ "def", "request", "(", "community_id", ",", "record_id", ",", "accept", ")", ":", "c", "=", "Community", ".", "get", "(", "community_id", ")", "assert", "c", "is", "not", "None", "record", "=", "Record", ".", "get_record", "(", "record_id", ")", "if", "accept", ":", "c", ".", "add_record", "(", "record", ")", "record", ".", "commit", "(", ")", "else", ":", "InclusionRequest", ".", "create", "(", "community", "=", "c", ",", "record", "=", "record", ",", "notify", "=", "False", ")", "db", ".", "session", ".", "commit", "(", ")", "RecordIndexer", "(", ")", ".", "index_by_id", "(", "record", ".", "id", ")" ]

[ "Request", "a", "record", "acceptance", "to", "a", "community", "." ]

[ "def", "remove", "(", "community_id", ",", "record_id", ")", ":", "c", "=", "Community", ".", "get", "(", "community_id", ")", "assert", "c", "is", "not", "None", "c", ".", "remove_record", "(", "record_id", ")", "db", ".", "session", ".", "commit", "(", ")", "RecordIndexer", "(", ")", ".", "index_by_id", "(", "record_id", ")" ]

[ "Remove", "a", "record", "from", "community", "." ]

[ "def", "gen_otu_dict", "(", "nex_obj", ",", "nexson_version", "=", "None", ")", ":", "if", "nexson_version", "is", "None", ":", "nexson_version", "=", "detect_nexson_version", "(", "nex_obj", ")", "if", "_is_by_id_hbf", "(", "nexson_version", ")", ":", "otus", "=", "nex_obj", "[", "'nexml'", "]", "[", "'otusById'", "]", "if", "len", "(", "otus", ")", ">", "1", ":", "d", "=", "{", "}", "for", "v", "in", "otus", ".", "values", "(", ")", ":", "d", ".", "update", "(", "v", "[", "'otuById'", "]", ")", "return", "d", "else", ":", "return", "otus", ".", "values", "(", ")", "[", "0", "]", "[", "'otuById'", "]", "o_dict", "=", "{", "}", "for", "ob", "in", "nex_obj", ".", "get", "(", "'otus'", ",", "[", "]", ")", ":", "for", "o", "in", "ob", ".", "get", "(", "'otu'", ",", "[", "]", ")", ":", "oid", "=", "o", "[", "'@id'", "]", "o_dict", "[", "oid", "]", "=", "o", "return", "o_dict" ]

[ "Takes", "a", "NexSON", "object", "and", "returns", "a", "dict", "of", "otu_id", "-", ">", "otu_obj" ]

[ "def", "set_country", "(", "request", ")", ":", "if", "request", ".", "method", "==", "'POST'", ":", "next", "=", "request", ".", "POST", ".", "get", "(", "'next'", ",", "request", ".", "GET", ".", "get", "(", "'next'", ")", ")", "if", "is_safe_url", "(", "url", "=", "next", ",", "host", "=", "request", ".", "get_host", "(", ")", ")", ":", "response", "=", "http", ".", "HttpResponseRedirect", "(", "next", ")", "else", ":", "response", "=", "http", ".", "HttpResponse", "(", ")", "country_code", "=", "request", ".", "POST", ".", "get", "(", "'country'", ",", "''", ")", ".", "upper", "(", ")", "if", "country_code", "!=", "geo", ".", "get_supported_country", "(", "country_code", ")", ":", "return", "http", ".", "HttpResponseBadRequest", "(", ")", "if", "hasattr", "(", "request", ",", "'session'", ")", ":", "request", ".", "session", "[", "geo", ".", "COUNTRY_SESSION_KEY", "]", "=", "country_code", "else", ":", "response", ".", "set_cookie", "(", "geo", ".", "COUNTRY_COOKIE_NAME", ",", "country_code", ",", "max_age", "=", "geo", ".", "COUNTRY_COOKIE_AGE", ",", "path", "=", "geo", ".", "COUNTRY_COOKIE_PATH", ")", "return", "response", "else", ":", "return", "http", ".", "HttpResponseNotAllowed", "(", "[", "'POST'", "]", ")" ]

[ "Sets", "the", "chosen", "country", "in", "the", "session", "or", "cookie", "." ]

[ "def", "reference", "(", "self", ",", "tkn", ":", "str", ")", ":", "return", "self", ".", "grammarelts", "[", "tkn", "]", "if", "tkn", "in", "self", ".", "grammarelts", "else", "UndefinedElement", "(", "tkn", ")" ]

[ "Return", "the", "element", "that", "tkn", "represents" ]

[ "def", "dependency_list", "(", "self", ",", "tkn", ":", "str", ")", "->", "List", "[", "str", "]", ":", "if", "tkn", "not", "in", "self", ".", "dependency_map", ":", "self", ".", "dependency_map", "[", "tkn", "]", "=", "[", "tkn", "]", "# Force a circular reference", "self", ".", "dependency_map", "[", "tkn", "]", "=", "self", ".", "reference", "(", "tkn", ")", ".", "dependency_list", "(", ")", "return", "self", ".", "dependency_map", "[", "tkn", "]" ]

[ "Return", "a", "list", "all", "of", "the", "grammarelts", "that", "depend", "on", "tkn" ]

[ "def", "dependencies", "(", "self", ",", "tkn", ":", "str", ")", "->", "Set", "[", "str", "]", ":", "return", "set", "(", "self", ".", "dependency_list", "(", "tkn", ")", ")" ]

[ "Return", "all", "the", "items", "that", "tkn", "depends", "on", "as", "a", "set" ]

[ "def", "undefined_entries", "(", "self", ")", "->", "Set", "[", "str", "]", ":", "return", "as_set", "(", "[", "[", "d", "for", "d", "in", "self", ".", "dependencies", "(", "k", ")", "if", "d", "not", "in", "self", ".", "grammarelts", "]", "for", "k", "in", "self", ".", "grammarelts", ".", "keys", "(", ")", "]", ")" ]

[ "Return", "the", "set", "of", "tokens", "that", "are", "referenced", "but", "not", "defined", "." ]

[ "def", "new_request", "(", "sender", ",", "request", "=", "None", ",", "notify", "=", "True", ",", "*", "*", "kwargs", ")", ":", "if", "current_app", ".", "config", "[", "'COMMUNITIES_MAIL_ENABLED'", "]", "and", "notify", ":", "send_community_request_email", "(", "request", ")" ]

[ "New", "request", "for", "inclusion", "." ]

[ "def", "inject_provisional_community", "(", "sender", ",", "json", "=", "None", ",", "record", "=", "None", ",", "index", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "index", "and", "not", "index", ".", "startswith", "(", "current_app", ".", "config", "[", "'COMMUNITIES_INDEX_PREFIX'", "]", ")", ":", "return", "json", "[", "'provisional_communities'", "]", "=", "list", "(", "sorted", "(", "[", "r", ".", "id_community", "for", "r", "in", "InclusionRequest", ".", "get_by_record", "(", "record", ".", "id", ")", "]", ")", ")" ]

[ "Inject", "provisional_communities", "key", "to", "ES", "index", "." ]

[ "def", "find_nodes", "(", "self", ",", "query_dict", "=", "None", ",", "exact", "=", "False", ",", "verbose", "=", "False", ",", "*", "*", "kwargs", ")", ":", "assert", "self", ".", "use_v1", "return", "self", ".", "_do_query", "(", "'{p}/singlePropertySearchForTreeNodes'", ".", "format", "(", "p", "=", "self", ".", "query_prefix", ")", ",", "query_dict", "=", "query_dict", ",", "exact", "=", "exact", ",", "verbose", "=", "verbose", ",", "valid_keys", "=", "self", ".", "node_search_term_set", ",", "kwargs", "=", "kwargs", ")" ]

[ "Query", "on", "node", "properties", ".", "See", "documentation", "for", "_OTIWrapper", "class", "." ]

[ "def", "find_trees", "(", "self", ",", "query_dict", "=", "None", ",", "exact", "=", "False", ",", "verbose", "=", "False", ",", "wrap_response", "=", "False", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "use_v1", ":", "uri", "=", "'{p}/singlePropertySearchForTrees'", ".", "format", "(", "p", "=", "self", ".", "query_prefix", ")", "else", ":", "uri", "=", "'{p}/find_trees'", ".", "format", "(", "p", "=", "self", ".", "query_prefix", ")", "resp", "=", "self", ".", "_do_query", "(", "uri", ",", "query_dict", "=", "query_dict", ",", "exact", "=", "exact", ",", "verbose", "=", "verbose", ",", "valid_keys", "=", "self", ".", "tree_search_term_set", ",", "kwargs", "=", "kwargs", ")", "if", "wrap_response", ":", "return", "TreeRefList", "(", "resp", ")", "return", "resp" ]

[ "Query", "on", "tree", "properties", ".", "See", "documentation", "for", "_OTIWrapper", "class", "." ]

[ "def", "find_studies", "(", "self", ",", "query_dict", "=", "None", ",", "exact", "=", "False", ",", "verbose", "=", "False", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "use_v1", ":", "uri", "=", "'{p}/singlePropertySearchForStudies'", ".", "format", "(", "p", "=", "self", ".", "query_prefix", ")", "else", ":", "uri", "=", "'{p}/find_studies'", ".", "format", "(", "p", "=", "self", ".", "query_prefix", ")", "return", "self", ".", "_do_query", "(", "uri", ",", "query_dict", "=", "query_dict", ",", "exact", "=", "exact", ",", "verbose", "=", "verbose", ",", "valid_keys", "=", "self", ".", "study_search_term_set", ",", "kwargs", "=", "kwargs", ")" ]

[ "Query", "on", "study", "properties", ".", "See", "documentation", "for", "_OTIWrapper", "class", "." ]

[ "def", "get_requirements", "(", ")", ":", "packages", "=", "[", "]", "with", "open", "(", "\"requirements.txt\"", ",", "\"r\"", ")", "as", "req_doc", ":", "for", "package", "in", "req_doc", ":", "packages", ".", "append", "(", "package", ".", "replace", "(", "\"\\n\"", ",", "\"\"", ")", ")", "return", "packages" ]

[ "returns", "requirements", "array", "for", "package" ]

[ "def", "TaxonomicAmendmentStore", "(", "repos_dict", "=", "None", ",", "repos_par", "=", "None", ",", "with_caching", "=", "True", ",", "assumed_doc_version", "=", "None", ",", "git_ssh", "=", "None", ",", "pkey", "=", "None", ",", "git_action_class", "=", "TaxonomicAmendmentsGitAction", ",", "mirror_info", "=", "None", ",", "infrastructure_commit_author", "=", "'OpenTree API <api@opentreeoflife.org>'", ")", ":", "global", "_THE_TAXONOMIC_AMENDMENT_STORE", "if", "_THE_TAXONOMIC_AMENDMENT_STORE", "is", "None", ":", "_THE_TAXONOMIC_AMENDMENT_STORE", "=", "_TaxonomicAmendmentStore", "(", "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_TAXONOMIC_AMENDMENT_STORE" ]

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

[ "def", "delete_marked_communities", "(", ")", ":", "# TODO: Delete the community ID from all records metadata first", "raise", "NotImplementedError", "(", ")", "Community", ".", "query", ".", "filter_by", "(", "Community", ".", "delete_time", ">", "datetime", ".", "utcnow", "(", ")", ")", ".", "delete", "(", ")", "db", ".", "session", ".", "commit", "(", ")" ]

[ "Delete", "communities", "after", "holdout", "time", "." ]

[ "def", "delete_expired_requests", "(", ")", ":", "InclusionRequest", ".", "query", ".", "filter_by", "(", "InclusionRequest", ".", "expiry_date", ">", "datetime", ".", "utcnow", "(", ")", ")", ".", "delete", "(", ")", "db", ".", "session", ".", "commit", "(", ")" ]

[ "Delete", "expired", "inclusion", "requests", "." ]

[ "def", "create_content_spec", "(", "*", "*", "kwargs", ")", ":", "format_str", "=", "kwargs", ".", "get", "(", "'format'", ",", "'nexson'", ")", "nexson_version", "=", "kwargs", ".", "get", "(", "'nexson_version'", ",", "'native'", ")", "otu_label", "=", "kwargs", ".", "get", "(", "'otu_label'", ")", "if", "otu_label", "is", "None", ":", "otu_label", "=", "kwargs", ".", "get", "(", "'tip_label'", ")", "content", "=", "kwargs", ".", "get", "(", "'content'", ")", "if", "content", "is", "not", "None", ":", "content_id", "=", "kwargs", ".", "get", "(", "'content_id'", ")", "if", "content_id", "is", "None", ":", "content_id", "=", "_get_content_id_from", "(", "*", "*", "kwargs", ")", "else", ":", "content", ",", "content_id", "=", "_sniff_content_from_kwargs", "(", "*", "*", "kwargs", ")", "if", "content", "is", "None", ":", "content", "=", "'study'", "return", "PhyloSchema", "(", "content", "=", "content", ",", "content_id", "=", "content_id", ",", "format_str", "=", "format_str", ",", "version", "=", "nexson_version", ",", "otu_label", "=", "otu_label", ",", "repo_nexml2json", "=", "kwargs", ".", "get", "(", "'repo_nexml2json'", ")", ",", "bracket_ingroup", "=", "bool", "(", "kwargs", ".", "get", "(", "'bracket_ingroup'", ",", "False", ")", ")", ",", "cull_nonmatching", "=", "kwargs", ".", "get", "(", "'cull_nonmatching'", ")", ")" ]

[ "Sugar", ".", "factory", "for", "a", "PhyloSchema", "object", "." ]

[ "def", "convert_nexson_format", "(", "blob", ",", "out_nexson_format", ",", "current_format", "=", "None", ",", "remove_old_structs", "=", "True", ",", "pristine_if_invalid", "=", "False", ",", "sort_arbitrary", "=", "False", ")", ":", "if", "not", "current_format", ":", "current_format", "=", "detect_nexson_version", "(", "blob", ")", "out_nexson_format", "=", "resolve_nexson_format", "(", "out_nexson_format", ")", "if", "current_format", "==", "out_nexson_format", ":", "if", "sort_arbitrary", ":", "sort_arbitrarily_ordered_nexson", "(", "blob", ")", "return", "blob", "two2zero", "=", "_is_by_id_hbf", "(", "out_nexson_format", ")", "and", "_is_badgerfish_version", "(", "current_format", ")", "zero2two", "=", "_is_by_id_hbf", "(", "current_format", ")", "and", "_is_badgerfish_version", "(", "out_nexson_format", ")", "if", "two2zero", "or", "zero2two", ":", "# go from 0.0 -> 1.0 then the 1.0->1.2 should succeed without nexml...", "blob", "=", "convert_nexson_format", "(", "blob", ",", "DIRECT_HONEY_BADGERFISH", ",", "current_format", "=", "current_format", ",", "remove_old_structs", "=", "remove_old_structs", ",", "pristine_if_invalid", "=", "pristine_if_invalid", ")", "current_format", "=", "DIRECT_HONEY_BADGERFISH", "ccdict", "=", "{", "'output_format'", ":", "out_nexson_format", ",", "'input_format'", ":", "current_format", ",", "'remove_old_structs'", ":", "remove_old_structs", ",", "'pristine_if_invalid'", ":", "pristine_if_invalid", "}", "ccfg", "=", "ConversionConfig", "(", "ccdict", ")", "if", "_is_badgerfish_version", "(", "current_format", ")", ":", "converter", "=", "Badgerfish2DirectNexson", "(", "ccfg", ")", "elif", "_is_badgerfish_version", "(", "out_nexson_format", ")", ":", "assert", "_is_direct_hbf", "(", "current_format", ")", "converter", "=", "Direct2BadgerfishNexson", "(", "ccfg", ")", "elif", "_is_direct_hbf", "(", "current_format", ")", "and", "(", "out_nexson_format", "==", "BY_ID_HONEY_BADGERFISH", ")", ":", "converter", "=", "Direct2OptimalNexson", "(", "ccfg", ")", "elif", "_is_direct_hbf", "(", "out_nexson_format", ")", "and", "(", "current_format", "==", "BY_ID_HONEY_BADGERFISH", ")", ":", "converter", "=", "Optimal2DirectNexson", "(", "ccfg", ")", "else", ":", "raise", "NotImplementedError", "(", "'Conversion from {i} to {o}'", ".", "format", "(", "i", "=", "current_format", ",", "o", "=", "out_nexson_format", ")", ")", "blob", "=", "converter", ".", "convert", "(", "blob", ")", "if", "sort_arbitrary", ":", "sort_arbitrarily_ordered_nexson", "(", "blob", ")", "return", "blob" ]

[ "Take", "a", "dict", "form", "of", "NexSON", "and", "converts", "its", "datastructures", "to", "those", "needed", "to", "serialize", "as", "out_nexson_format", ".", "If", "current_format", "is", "not", "specified", "it", "will", "be", "inferred", ".", "If", "remove_old_structs", "is", "False", "and", "different", "honeybadgerfish", "varieties", "are", "selected", "the", "blob", "will", "be", "fat", "containing", "both", "types", "of", "lookup", "structures", ".", "If", "pristine_if_invalid", "is", "False", "then", "the", "object", "may", "be", "corrupted", "if", "it", "is", "an", "invalid", "nexson", "struct", ".", "Setting", "this", "to", "False", "can", "result", "in", "faster", "translation", "but", "if", "an", "exception", "is", "raised", "the", "object", "may", "be", "polluted", "with", "partially", "constructed", "fields", "for", "the", "out_nexson_format", "." ]