Exemple #1
0
class CreativeWork(Parser):
    title = ctx.title
    description = tools.Try(ctx.description)
    is_deleted = tools.RunPython('_is_deleted', tools.Try(ctx.otherProperties))
    date_updated = tools.ParseDate(tools.Try(ctx.providerUpdatedDateTime))
    rights = tools.Join(tools.Try(ctx.licenses.uri))

    # Note: this is only taking the first language in the case of multiple languages
    language = tools.ParseLanguage(tools.Try(ctx.languages[0]), )

    related_agents = tools.Concat(
        tools.Map(tools.Delegate(Creator), tools.Try(ctx.contributors)),
        tools.Map(tools.Delegate(Publisher), tools.Try(ctx.publisher)),
        tools.Map(tools.Delegate(Funder), tools.Try(ctx.sponsorships)))

    identifiers = tools.Map(
        tools.Delegate(WorkIdentifier),
        tools.Map(
            tools.IRI(),
            tools.RunPython(
                'unique',
                tools.Concat(tools.Try(ctx.uris.canonicalUri),
                             tools.Try(ctx.uris.providerUris),
                             tools.Try(ctx.uris.descriptorUris),
                             tools.Try(ctx.uris.objectUris)))))

    subjects = tools.Map(tools.Delegate(ThroughSubjects),
                         tools.Subjects(tools.Try(ctx.subjects)))

    tags = tools.Map(tools.Delegate(ThroughTags), tools.Try(ctx.tags),
                     tools.Try(ctx.subjects))

    class Extra:
        """
        Fields that are combined in the base parser are relisted as singular elements that match
        their original entry to preserve raw data structure.
        """
        freeToRead = tools.Try(ctx.freeToRead)
        languages = tools.Try(ctx.languages)
        licenses = tools.Try(ctx.licenses)
        otherProperties = tools.Try(ctx.otherProperties)
        publisher = tools.Try(ctx.publisher)
        subjects = tools.Try(ctx.subjects)
        sponsorships = tools.Try(ctx.sponsorships)
        tags = tools.Try(ctx.tags)
        uris = tools.Try(ctx.uris)
        version = tools.Try(ctx.version)

    def unique(self, items):
        return list(sorted(set(items)))

    def _is_deleted(self, properties):
        for prop in properties or []:
            if prop['name'] == 'status':
                return 'deleted' in prop['properties'].get('status', [])
        return False
Exemple #2
0
class AffiliatedAgent(Parser):
    schema = tools.GuessAgentType(ctx.awardeeName, default='organization')

    name = ctx.awardeeName
    location = tools.Join(tools.Concat(ctx.awardeeCity,
                                       tools.Try(ctx.awardeeStateCode)),
                          joiner=', ')

    class Extra:
        awardee_city = ctx.awardeeCity
        awardee_state_code = tools.Try(ctx.awardeeStateCode)
class Dataset(Parser):
    title = tools.Try(ctx['title'])
    description = tools.Try(ctx['description'])

    rights = tools.Try(
        tools.Join(
            tools.Concat(tools.Try(ctx['access-rights']),
                         tools.Try(ctx['usage-rights']))))

    related_agents = tools.Map(tools.Delegate(Creator), tools.Try(ctx.contact))

    class Extra:
        access_rights = tools.Try(ctx['access-rights'])
        usage_rights = tools.Try(ctx['usage-rights'])
        collection_statistics = tools.Try(ctx['collection-statistics'])
        management = tools.Try(ctx['management'])
        collection_type = tools.Try(ctx['collection-type'])
        last_update = tools.ParseDate(tools.Try(ctx['last-update']))
Exemple #4
0
class DataSet(Parser):
    title = tools.Join(tools.Try(ctx.record.metadata.DIF.Entry_Title))
    description = tools.Try(ctx.record.metadata.DIF.Summary.Abstract)

    related_agents = tools.Map(
        tools.Delegate(AgentWorkRelation),
        tools.Try(ctx.record.metadata.DIF.Data_Center)
    )

    tags = tools.Map(
        tools.Delegate(ThroughTags),
        tools.Try(ctx.record.metadata.DIF.Metadata_Name),
        tools.Try(ctx.record.header.setSpec)
    )

    identifiers = tools.Map(tools.Delegate(WorkIdentifier), tools.Try(ctx.record.metadata.DIF))

    date_updated = tools.ParseDate(ctx.record.header.datestamp)

    is_deleted = tools.RunPython('check_status', tools.Try(ctx.record.header['@status']))

    class Extra:
        status = tools.Try(ctx.record.header['@status'])

        entry_id = tools.Try(ctx.record.metadata.DIF.Entry_ID)

        metadata_name = tools.Try(ctx.record.metadata.DIF.Metadata_Name)

        metadata_version = tools.Try(ctx.record.metadata.DIF.Metadata_Version)

        last_dif_revision_date = tools.Try(ctx.record.metadata.DIF.Last_DIF_Revision_Date)

        set_spec = ctx.record.header.setSpec

    def check_status(self, status):
        if status == 'deleted':
            return True
        return False
Exemple #5
0
class OAICreativeWork(Parser):
    default_type = None
    type_map = None

    schema = tools.RunPython(
        'get_schema',
        tools.OneOf(ctx.record.metadata.dc['dc:type'], tools.Static(None)))

    title = tools.Join(
        tools.RunPython(force_text,
                        tools.Try(ctx.record.metadata.dc['dc:title'])))
    description = tools.Join(
        tools.RunPython(force_text,
                        tools.Try(ctx.record.metadata.dc['dc:description'])))

    identifiers = tools.Map(
        tools.Delegate(OAIWorkIdentifier),
        tools.Unique(
            tools.Map(
                tools.Try(tools.IRI(), exceptions=(InvalidIRI, )),
                tools.Filter(
                    not_citation,
                    tools.RunPython(
                        force_text,
                        tools.Concat(
                            tools.Try(ctx.record.metadata.dc['dc:identifier']),
                            tools.Try(ctx.record.header['identifier'])))))))

    related_works = tools.Concat(
        tools.Map(
            tools.Delegate(OAIWorkRelation),
            tools.Unique(
                tools.Map(tools.Try(tools.IRI(), exceptions=(InvalidIRI, )),
                          tools.RunPython('get_relation', ctx)))))

    related_agents = tools.Concat(
        tools.Map(tools.Delegate(OAICreator),
                  tools.Try(ctx.record.metadata.dc['dc:creator'])),
        tools.Map(tools.Delegate(OAIContributor),
                  tools.Try(ctx.record.metadata.dc['dc:contributor'])),
        tools.Map(
            tools.Delegate(OAIPublisher),
            tools.RunPython(force_text,
                            tools.Try(
                                ctx.record.metadata.dc['dc:publisher']))),
    )

    rights = tools.Join(tools.Try(ctx.record.metadata.dc['dc:rights']))

    # Note: this is only taking the first language in the case of multiple languages
    language = tools.ParseLanguage(
        tools.Try(ctx.record.metadata.dc['dc:language'][0]), )

    subjects = tools.Map(
        tools.Delegate(OAIThroughSubjects),
        tools.Subjects(
            tools.Map(
                tools.RunPython('tokenize'),
                tools.RunPython(
                    force_text,
                    tools.Concat(
                        tools.Try(ctx.record.header.setSpec),
                        tools.Try(ctx.record.metadata.dc['dc:type']),
                        tools.Try(ctx.record.metadata.dc['dc:format']),
                        tools.Try(ctx.record.metadata.dc['dc:subject']),
                    )))))

    tags = tools.Map(
        tools.Delegate(OAIThroughTags),
        tools.Concat(tools.Map(
            tools.RunPython('tokenize'),
            tools.RunPython(
                force_text,
                tools.Concat(
                    tools.Try(ctx.record.header.setSpec),
                    tools.Try(ctx.record.metadata.dc['dc:type']),
                    tools.Try(ctx.record.metadata.dc['dc:format']),
                    tools.Try(ctx.record.metadata.dc['dc:subject']),
                ))),
                     deep=True))

    date_updated = tools.ParseDate(ctx.record.header.datestamp)

    is_deleted = tools.RunPython('check_status',
                                 tools.Try(ctx.record.header['@status']))

    class Extra:
        """
        Fields that are combined in the base parser are relisted as singular elements that match
        their original entry to preserve raw data structure.
        """
        # An agent responsible for making contributions to the resource.
        contributor = tools.Try(ctx.record.metadata.dc['dc:contributor'])

        # The spatial or temporal topic of the resource, the spatial applicability of the resource,
        # or the jurisdiction under which the resource is relevant.
        coverage = tools.Try(ctx.record.metadata.dc['dc:coverage'])

        # An agent primarily responsible for making the resource.
        creator = tools.Try(ctx.record.metadata.dc['dc:creator'])

        # A point or period of time associated with an event in the lifecycle of the resource.
        dates = tools.Try(ctx.record.metadata.dc['dc:date'])

        # The file format, physical medium, or dimensions of the resource.
        resource_format = tools.Try(ctx.record.metadata.dc['dc:format'])

        # An unambiguous reference to the resource within a given context.
        identifiers = tools.Concat(
            tools.Try(ctx.record.metadata.dc['dc:identifier']),
            tools.Try(ctx.record.header['identifier']))

        # A related resource.
        relation = tools.RunPython('get_relation', ctx)

        # A related resource from which the described resource is derived.
        source = tools.Try(ctx.record.metadata.dc['dc:source'])

        # The nature or genre of the resource.
        resource_type = tools.Try(ctx.record.metadata.dc['dc:type'])

        set_spec = tools.Try(ctx.record.header.setSpec)

        # Language also stored in the Extra class in case the language reported cannot be parsed by ParseLanguage
        language = tools.Try(ctx.record.metadata.dc['dc:language'])

        # Status in the header, will exist if the resource is deleted
        status = tools.Try(ctx.record.header['@status'])

    def check_status(self, status):
        if status == 'deleted':
            return True
        return False

    def get_schema(self, types):
        if not types or not self.type_map:
            return self.default_type
        if isinstance(types, str):
            types = [types]
        for t in types:
            if isinstance(t, dict):
                t = t['#text']
            t = t.lower()
            if t in self.type_map:
                return self.type_map[t]
        return self.default_type

    def tokenize(self, data):
        if isinstance(data, str):
            data = [data]
        tokens = []
        for item in data:
            tokens.extend(
                [x.strip() for x in re.split(r'(?: - )|\.|,', item) if x])
        return tokens

    def get_relation(self, ctx):
        if not ctx['record'].get('metadata'):
            return []
        relation = ctx['record']['metadata']['dc'].get('dc:relation') or []
        identifiers = ctx['record']['metadata']['dc'].get(
            'dc:identifier') or []
        if isinstance(identifiers, dict):
            identifiers = (identifiers, )
        identifiers = ''.join(i['#text'] if isinstance(i, dict) else i
                              for i in identifiers if i)

        identifiers = re.sub(
            'http|:|/', '',
            identifiers + ctx['record']['header']['identifier'])

        if isinstance(relation, dict):
            relation = (relation['#text'], )

        return [
            r for r in relation
            if r and re.sub('http|:|/', '', r) not in identifiers
        ]
Exemple #6
0
class MODSCreativeWork(Parser):
    default_type = 'CreativeWork'
    type_map = None
    role_map = None

    schema = tools.RunPython(
        'get_schema',
        tools.OneOf(tools.RunPython(force_text, ctx['mods:genre']),
                    tools.Static(None)))

    title = tools.RunPython('join_title_info', ctx)

    # Abstracts have the optional attribute "shareable". Don't bother checking for it, because
    # abstracts that are not shareable should not have been shared with SHARE.
    description = tools.Join(
        tools.RunPython(force_text, tools.Try(ctx['mods:abstract']), '\n'))

    identifiers = tools.Map(
        tools.Delegate(MODSWorkIdentifier),
        tools.Unique(
            tools.Map(
                tools.Try(tools.IRI(), exceptions=(ValueError, )),
                tools.Map(
                    tools.RunPython(force_text),
                    tools.Filter(
                        lambda obj: 'invalid' not in obj,
                        tools.Concat(
                            tools.Try(ctx['mods:identifier']),
                            tools.Try(ctx.header['identifier']),
                            tools.Try(ctx['mods:location']['mods:url']),
                        ))))))

    related_works = tools.Concat(
        tools.Map(tools.Delegate(MODSWorkRelation),
                  tools.Try(ctx['mods:relatedItem'])))

    related_agents = tools.Concat(
        tools.Map(tools.Delegate(MODSCreator),
                  tools.RunPython('filter_names', ctx, 'creator')),
        tools.Map(tools.Delegate(MODSFunder),
                  tools.RunPython('filter_names', ctx, 'funder')),
        tools.Map(tools.Delegate(MODSHost),
                  tools.RunPython('filter_names', ctx, 'host')),
        tools.Map(tools.Delegate(MODSPublisher),
                  tools.RunPython('filter_names', ctx, 'publisher')),
        tools.Map(
            tools.Delegate(MODSContributor),
            tools.RunPython('filter_names',
                            ctx,
                            'creator',
                            'funder',
                            'host',
                            'publisher',
                            invert=True)),
        tools.Map(
            tools.Delegate(MODSSimplePublisher),
            tools.Try(ctx['mods:originInfo']['mods:publisher']),
        ),
    )

    rights = tools.RunPython(force_text,
                             tools.Try(ctx['mods:accessCondition']), '\n')

    language = tools.ParseLanguage(
        tools.Try(ctx['mods:language']['mods:languageTerm']), )

    subjects = tools.Map(
        tools.Delegate(MODSThroughSubjects),
        tools.Subjects(
            tools.Concat(tools.Try(ctx['mods:subject']['mods:topic']), )))

    tags = tools.Map(
        tools.Delegate(MODSThroughTags),
        tools.Concat(tools.Map(
            tools.RunPython('tokenize'),
            tools.Map(
                tools.RunPython(force_text),
                tools.Try(ctx.header.setSpec),
                tools.Try(ctx['mods:genre']),
                tools.Try(ctx['mods:classification']),
                tools.Try(ctx['mods:subject']['mods:topic']),
            )),
                     deep=True))

    date_updated = tools.ParseDate(tools.Try(ctx.header.datestamp))

    # TODO (in regulator) handle date ranges, uncertain dates ('1904-1941', '1890?', '1980-', '19uu', etc.)
    date_published = tools.OneOf(
        tools.ParseDate(
            tools.RunPython(
                force_text,
                tools.Try(ctx['mods:originInfo']['mods:dateIssued']))),
        tools.Static(None))

    is_deleted = tools.RunPython(lambda status: status == 'deleted',
                                 tools.Try(ctx.record.header['@status']))

    class Extra:
        """
        Fields that are combined in the base parser are relisted as singular elements that match
        their original entry to preserve raw data structure.
        """

        # (dc:description) http://www.loc.gov/standards/mods/userguide/abstract.html
        abstract = tools.Try(ctx['mods:abstract'])

        # (dc:rights) http://www.loc.gov/standards/mods/userguide/accesscondition.html
        accessConditions = tools.Try(ctx['mods:accessCondition'])

        # (dc:subject) http://www.loc.gov/standards/mods/userguide/classification.html
        classification = tools.Try(ctx['mods:classification'])

        # (N/A) http://www.loc.gov/standards/mods/userguide/extension.html
        extension = tools.Try(ctx['mods:extension'])

        # SHARE type
        # (dc:type) http://www.loc.gov/standards/mods/userguide/genre.html
        genre = tools.Try(ctx['mods:genre'])

        # (dc:identifier) http://www.loc.gov/standards/mods/userguide/identifier.html
        identifier = tools.Try(ctx['mods:identifier'])

        # (dc:language) http://www.loc.gov/standards/mods/userguide/language.html
        language = tools.Try(ctx['mods:language'])

        # (dc:identifier for url) http://www.loc.gov/standards/mods/userguide/location.html
        location = tools.Try(ctx['mods:location'])

        # (dc:creator|dc:contributor) http://www.loc.gov/standards/mods/userguide/name.html
        name = tools.Try(ctx['mods:name'])

        # (dc:description) http://www.loc.gov/standards/mods/userguide/note.html
        note = tools.Try(ctx['mods:note'])

        # (dc:publisher|dc:date) http://www.loc.gov/standards/mods/userguide/origininfo.html
        originInfo = tools.Try(ctx['mods:originInfo'])

        # Extra
        # (dc:title) http://www.loc.gov/standards/mods/userguide/part.html
        part = tools.Try(ctx['mods:part'])

        # (dc:format or N/A) http://www.loc.gov/standards/mods/userguide/physicaldescription.html
        physicalDescription = tools.Try(ctx['mods:physicalDescription'])

        # Metadata information
        # (N/A) http://www.loc.gov/standards/mods/userguide/recordinfo.html
        recordInfo = tools.Try(ctx['mods:recordInfo'])

        # (dc:relation) http://www.loc.gov/standards/mods/userguide/relateditem.html
        relatedItem = tools.Try(ctx['mods:relatedItem'])

        # (dc:subject|dc:type|dc:coverage|N/A) http://www.loc.gov/standards/mods/userguide/subject.html
        subject = tools.Try(ctx['mods:subject'])

        # (dc:description) http://www.loc.gov/standards/mods/userguide/tableofcontents.html
        tableOfContents = tools.Try(ctx['mods:tableOfContents'])

        # (N/A) http://www.loc.gov/standards/mods/userguide/targetaudience.html
        targetAudience = tools.Try(ctx['mods:targetAudience'])

        # (dc:title) http://www.loc.gov/standards/mods/userguide/titleinfo.html
        titleInfo = tools.Try(ctx['mods:titleInfo'])

        # Extra
        # (dc:type) http://www.loc.gov/standards/mods/userguide/typeofresource.html
        typeOfResource = tools.Try(ctx['mods:typeOfResource'])

    def get_schema(self, types):
        if not types or not self.type_map:
            return self.default_type
        if isinstance(types, str):
            types = [types]
        for t in types:
            if isinstance(t, dict):
                t = t['#text']
            t = t.lower()
            if t in self.type_map:
                return self.type_map[t]
        return self.default_type

    def tokenize(self, data):
        if isinstance(data, str):
            data = [data]
        tokens = []
        for item in data:
            tokens.extend(
                [x.strip() for x in re.split(r'(?: - )|\.|,', item) if x])
        return tokens

    # Map titleInfos to a string: https://www.loc.gov/standards/mods/userguide/titleinfo.html#mappings
    def join_title_info(self, obj):
        def get_part(title_info, part_name, delimiter=''):
            part = force_text(title_info.get(part_name, ''), ' ').strip()
            return delimiter + part if part else ''

        title_infos = get_list(obj, 'mods:titleInfo')
        titles = []
        for title_info in title_infos:
            title = ''
            title += get_part(title_info, 'mods:nonSort')
            title += get_part(title_info, 'mods:title')
            title += get_part(title_info, 'mods:subTitle', ': ')
            title += get_part(title_info, 'mods:partNumber', '. ')
            title += get_part(title_info, 'mods:partName', ': ')
            if title:
                titles.append(title)
        return '. '.join(titles)

    def filter_names(self, obj, *roles, invert=False):
        names = get_list(obj, 'mods:name')
        filtered = [*names] if invert else []
        for name in names:
            name_roles = get_list(name, 'mods:role')
            for role in name_roles:
                role_terms = get_list(role, 'mods:roleTerm')
                name_roles = {force_text(r).lower() for r in role_terms}
                name_roles.update({
                    self.role_map[r]
                    for r in name_roles if r in self.role_map
                })
                if name_roles.intersection(roles):
                    if invert:
                        filtered.remove(name)
                    else:
                        filtered.append(name)
        return filtered
Exemple #7
0
class PIContributorRelation(Parser):
    schema = 'PrincipalInvestigatorContact'

    agent = tools.Delegate(PIContributorAgent, ctx)
    cited_as = tools.Join(tools.Concat(ctx.piFirstName, ctx.piLastName),
                          joiner=' ')
Exemple #8
0
class ContributorRelation(Parser):
    schema = 'Contributor'

    agent = tools.Delegate(ContributorAgent, ctx)
    cited_as = tools.Join(tools.Concat(ctx.piFirstName, ctx.piLastName),
                          joiner=' ')
Exemple #9
0
class CreativeWork(Parser):
    '''
    Documentation for Datacite's metadata:
    https://schema.labs.datacite.org/meta/kernel-4.0/doc/DataCite-MetadataKernel_v4.0.pdf
    '''
    def get_schema(self, type):
        return {
            'dataset': 'DataSet',
            'software': 'Software',
            'text/book': 'Book',
            'text/book chapter': 'Book',
            'text/book prospectus': 'Book',
            'text/book series': 'Book',
            'text/conference abstract': 'ConferencePaper',
            'text/conference paper': 'ConferencePaper',
            'text/conference poster': 'Poster',
            'text/dissertation': 'Dissertation',
            'text/edited book': 'Book',
            'text/journal article': 'Article',
            'text/journal issue': 'Article',
            'text/patent': 'Patent',
            'text/report': 'Report',
            'text/supervised student publication': 'Thesis',
            'text/working paper': 'WorkingPaper'

            # 'audiovisual': '',
            # 'collection': '',
            # 'event': '',
            # 'image': '',
            # 'interactiveresource': '',
            # 'model': '',
            # 'physicalobject': '',
            # 'service': '',
            # 'sound': '',
            # 'text15': '',
            # 'workflow': '',
            # 'text/book review': '',
            # 'text/conference program': '',
            # 'text/dictionary entry': '',
            # 'text/disclosure': '',
            # 'text/encyclopedia entry': '',
            # 'text/Funding submission': '',
            # 'text/license': '',
            # 'text/magazine article': '',
            # 'text/manual': '',
            # 'text/newsletter article': '',
            # 'text/newspaper article': '',
            # 'text/online resource': '',
            # 'text/registered copyright': '',
            # 'text/research tool': '',
            # 'text/tenure-promotion': '',
            # 'text/test': '',
            # 'text/trademark': '',
            # 'text/translation': '',
            # 'text/university academic unit': '',
            # 'text/website': '',
        }.get(type.lower()) or 'CreativeWork'

    schema = tools.RunPython(
        'get_schema',
        tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                  resourceType['@resourceTypeGeneral'],
                  default='CreativeWork'))

    title = tools.RunPython(
        force_text,
        tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.titles.title),
        first_str=True)

    description = tools.Try(
        tools.Join(
            tools.RunPython(
                force_text,
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          descriptions.description))))

    rights = tools.Try(
        tools.Join(
            tools.RunPython(
                force_text,
                tools.Concat(ctx.record.metadata['oai_datacite'].payload.
                             resource.rightsList.rights))))

    language = tools.ParseLanguage(
        tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.language))

    related_agents = tools.Concat(
        tools.Map(
            tools.Delegate(CreatorRelation),
            tools.Concat(
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          creators.creator))),
        tools.Map(
            tools.Delegate(ContributorRelation),
            tools.Concat(
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          contributors.contributor))),
        tools.Map(
            tools.Delegate(PublisherRelation),
            tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                      publisher)),
        tools.Map(
            tools.Delegate(HostRelation),
            tools.RunPython(
                get_contributors,
                tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.contributors.contributor)),
                ['HostingInstitution'])),
        # v.3 Funder is a contributor type
        # v.4 FundingReference replaces funder contributor type
        tools.Map(
            tools.Delegate(FunderRelation),
            tools.RunPython(
                get_contributors,
                tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.contributors.contributor)),
                ['Funder'])),
        tools.Map(
            tools.Delegate(FunderRelation),
            tools.Concat(
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          fundingReference))))

    # v.4 New, free text, 'subjectScheme' attribute on subject
    subjects = tools.Map(
        tools.Delegate(ThroughSubjects),
        tools.Subjects(
            tools.RunPython(
                force_text,
                tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.subjects.subject), ))))

    tags = tools.Map(
        tools.Delegate(ThroughTags),
        tools.RunPython(
            force_text,
            tools.Concat(
                tools.Maybe(
                    tools.Maybe(ctx.record, 'metadata')['oai_datacite'],
                    'type'),
                tools.RunPython(force_text, (tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.subjects.subject)))),
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          formats.format),
                tools.Try(
                    ctx.record.metadata['oai_datacite'].datacentreSymbol),
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          resourceType['#text']),
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          resourceType['@resourceTypeGeneral']),
                tools.Maybe(ctx.record.header, 'setSpec'),
                tools.Maybe(ctx.record.header, '@status'))))

    identifiers = tools.Concat(
        tools.Map(
            tools.Delegate(WorkIdentifier),
            tools.Concat(
                tools.Try(ctx.record.metadata['oai_datacite'].payload.resource.
                          identifier))),
        tools.Map(
            tools.Delegate(
                WorkIdentifier,
                tools.RunPython(force_text,
                                ctx.alternateIdentifier)), ctx.record.
            metadata['oai_datacite'].payload.resource.alternateIdentifiers),
    )

    related_works = tools.Concat(
        tools.Map(
            tools.Delegate(WorkRelation),
            tools.RunPython(
                get_related_works,
                tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.relatedIdentifiers.relatedIdentifier)),
                False)),
        tools.Map(
            tools.Delegate(InverseWorkRelation),
            tools.RunPython(
                get_related_works,
                tools.Concat(
                    tools.Try(ctx.record.metadata['oai_datacite'].payload.
                              resource.relatedIdentifiers.relatedIdentifier)),
                True)))

    date_updated = tools.ParseDate(tools.Try(ctx.record.header.datestamp))
    date_published = tools.ParseDate(
        tools.Try(
            tools.RunPython(
                'get_date_type',
                tools.Concat(ctx.record.metadata['oai_datacite'].payload.
                             resource.dates.date), 'Issued')))
    free_to_read_type = tools.Try(
        tools.IRI(ctx.record.metadata['oai_datacite'].payload.resource.
                  rightsList.rights['@rightsURI']),
        exceptions=(ValueError, ))
    free_to_read_date = tools.ParseDate(
        tools.Try(
            tools.RunPython(
                'get_date_type',
                tools.Concat(ctx.record.metadata['oai_datacite'].payload.
                             resource.dates.date), 'Available')))

    is_deleted = tools.RunPython('check_status',
                                 tools.Try(ctx.record.header['@status']))

    class Extra:
        """
        Fields that are combined in the base parser are relisted as singular elements that match
        their original entry to preserve raw data structure.
        """
        status = tools.Try(ctx.record.header['@status'])

        datestamp = tools.ParseDate(ctx.record.header.datestamp)

        set_spec = tools.Try(ctx.record.header.setSpec)

        is_reference_quality = tools.Try(
            ctx.record.metadata['oai_datacite'].isReferenceQuality)

        schema_version = tools.Try(
            ctx.record.metadata['oai_datacite'].schemaVersion)

        datacentre_symbol = tools.Try(
            ctx.record.metadata['oai_datacite'].datacentreSymbol)

        identifiers = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.identifier)

        alternate_identifiers = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.
            alternateIdentifiers.alternateidentifier)

        titles = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.titles.title)

        publisher = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.publisher)

        publication_year = tools.Try(ctx.record.metadata['oai_datacite'].
                                     payload.resource.publicationYear)

        subject = tools.Try(ctx.record.metadata['oai_datacite'].payload.
                            resource.subjects.subject)

        resourceType = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.resourceType)

        sizes = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.size)

        format_type = tools.Try(ctx.record.metadata['oai_datacite'].payload.
                                resource.formats.format)

        version = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.version)

        rights = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.rights)

        rightsList = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.rightsList)

        related_identifiers = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.
            relatedIdentifiers.relatedIdentifier)

        description = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.descriptions)

        dates = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.dates.date)

        contributors = tools.Try(ctx.record.metadata['oai_datacite'].payload.
                                 resource.contributors.contributor)

        creators = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.creators)

        # v.4 new property geoLocationPolygon, in addition to geoLocationPoint and geoLocationBox
        geolocations = tools.Try(
            ctx.record.metadata['oai_datacite'].payload.resource.geoLocations)

        funding_reference = tools.Try(ctx.record.metadata['oai_datacite'].
                                      payload.resource.fundingReference)

    def check_status(self, status):
        if status == 'deleted':
            return True
        return False

    def get_date_type(self, date_obj, date_type):
        date = None
        for obj in date_obj:
            if obj['@dateType'] == date_type:
                date = obj['#text']
        if date and date != '0000':
            return date
        # raise KeyError to break TryLink
        raise KeyError()
Exemple #10
0
class Creator(Parser):
    agent = Delegate(Person, ctx)
    order_cited = ctx('index')

    cited_as = links.Join(Concat(Maybe(ctx, 'given'), Maybe(ctx, 'family')),
                          joiner=' ')