def author_keywords(soup):
    # A few articles have kwd-group with no kwd-group-type, so account for those
    tags = extract_nodes(soup, "kwd-group")
    keyword_tags = []
    for tag in tags:
        if (tag.get("kwd-group-type") == "author-keywords" 
            or tag.get("kwd-group-type") is None):
            keyword_tags += filter(lambda tag: tag.name == "kwd", tag)
    return keyword_tags

def full_subject_area(soup, subject_group_type=None):

    subject_group_tags = extract_nodes(soup, "subj-group")
    subject_group_tags = filter(lambda tag: tag.parent.name == "article-categories"
                                              and tag.parent.parent.name == "article-meta", subject_group_tags)

    if subject_group_type:
        subject_group_tags = filter(lambda tag:
                                    tag.get("subj-group-type" == subject_group_type))

    return subject_group_tags

def subject_area(soup, subject_group_type = None):
    # Supports all subject areas or just particular ones filtered by 
    subject_area_tags = []
    tags = extract_nodes(soup, "subject")
    
    subject_area_tags = filter(lambda tag: tag.parent.name == "subj-group" \
                                           and tag.parent.parent.name == "article-categories" \
                                           and tag.parent.parent.parent.name == "article-meta", tags)
    if subject_group_type:
        subject_area_tags = filter(lambda tag:
                                    tag.parent.get("subj-group-type") == subject_group_type, tags)
    return subject_area_tags

def simulate(vbmap):
    pylab.figure()

    nodes = extract_nodes(vbmap['map'])
    nodes_count = len(nodes)

    vbmaps = simulate_failovers(vbmap)

    charts_count = len(vbmaps)
    rows = cols = int(math.ceil(math.sqrt(charts_count)))

    def plot(vbmap, chart):
        pylab.subplot(rows, cols, chart)
        masters = [n for n in extract_masters(vbmap) if n is not None]

        pylab.xticks([i + 0.5 for i in xrange(nodes_count)], nodes)
        pylab.hist(masters, bins=xrange(nodes_count + 1))
        pylab.xlabel("Nodes")
        pylab.ylabel("Number of vbuckets")
        pylab.legend()

    for chart, vbmap in enumerate(vbmaps, 1):
        plot(vbmap, chart)

def funding_statement(soup):
    return first(extract_nodes(soup, "funding-statement"))

def copyright_year(soup):
    return first(extract_nodes(permissions(soup), "copyright-year"))

def article_title(soup):
    return first(extract_nodes(soup, "article-title"))

def licence(soup):
    return first(extract_nodes(permissions(soup), "license"))

def conflict(soup):
    return extract_nodes(soup, "fn", attr = "fn-type", value = "conflict")

def publisher(soup):
    return first(extract_nodes(soup, "publisher-name"))

def journal_issn(soup, pub_format):
    return first(extract_nodes(soup, "issn", attr = "publication-format", value = pub_format))

def journal_title(soup):
    return first(extract_nodes(soup, "journal-title"))

def journal_id(soup):
    # the first non-nil tag
    return firstnn(extract_nodes(soup, "journal-id", attr = "journal-id-type", value = "hwp"))

def publisher_id(soup):
    article_id_tags = extract_nodes(soup, "article-id", attr = "pub-id-type", value = "publisher-id")
    # the first article-id tag whose parent is article-meta
    return first(filter(lambda tag: tag.parent.name == "article-meta", article_id_tags))

def doi(soup):
    doi_tags = extract_nodes(soup, "article-id", attr = "pub-id-type", value = "doi")
    # the first article-id tag whose parent is article-meta
    return first(filter(lambda tag: tag.parent.name == "article-meta", doi_tags))

def keyword_group(soup):
    return extract_nodes(soup, "kwd-group")

def acknowledgements(soup):
    return first(extract_nodes(soup, "ack"))

def article_type(soup):
    # returns raw data, just that the data doesn't contain any BS nodes
    return first(extract_nodes(soup, "article")).get('article-type')

def permissions(soup):
    # a better selector might be "article-meta.permissions"
    return first(extract_nodes(soup, "permissions"))

def pub_date(soup, date_type):
    return first(extract_nodes(soup, "pub-date", attr = "date-type", value = date_type))