def test_is_dummy(self):
""" Test the is_dummy method """
dummy_record = {
'001': [([], ' ', ' ', '1', 1)]
}
record = AmendableRecord(dummy_record)
self.assertTrue(record.is_dummy())
def show_papers(personid, external_id=None, orcid=None, inspire=None):
search = 'select * from aidPERSONIDPAPERS where personid='
search += str(personid) + ' and flag>-2'
result = run_sql(search)
hep_records = ''
for personid, table, bibref, bibrec, author, match, flag, cul, date \
in result:
#for personid, table, bibref, bibrec, author in result:
#rec = AmendableRecord(get_bibrecord(bibrec))
position = -1
author_name = get_name_by_bibref((table, bibref))
for key, value in AmendableRecord(get_bibrecord(bibrec)).\
iterfields(['{0}__%'.format(table, )]):
if (key[0] == '700__a' or key[0] == '100__a') and \
value == author_name:
position = key[1]
if position >= 0:
for key, value in AmendableRecord(get_bibrecord(bibrec)).\
iterfields(['{0}__%'.format(table, )]):
if key[1] == position and key[0] in \
('{0}__a'.format(table), '{0}__i'.
format(table), '{0}__j'.format(table),
'{0}__k'.format(table), '{0}__m'.format(table), ):
if value.replace('ORCID:', '') == external_id and \
value.replace('ORCID:', '') != orcid and \
value != inspire:
hep_records += " " + " ".join([str(bibrec),
author, value, '\n'])
if hep_records:
return hep_records
return None
def getInspireRecordMetadata(inspireID):
'''For a given INSPIRE ID, collect the desired metadata fields
and return them.
'''
fieldArray = {'0247_2': 'stdIDsource', '0247_a': 'stdID',
'245__a': 'title', '8564_u': 'files'}
fieldValues = {}
fieldKeys = fieldArray.keys()
for fKey in fieldKeys:
fieldValues[fKey] = get_fieldvalues(inspireID, fKey)
print "fieldValues=", fKey, ":", fieldValues[fKey]
# ThS suggested approach for dealing with the problem of two repeating
# fields that correspond (say, a type in one field, and a value in another)
record = AmendableRecord(get_bibrecord(inspireID))
for _, val in record.iterfield('035__a', subfield_filter=('9', 'arXiv')):
fieldValues['arxivID'] = val
pdfList = []
for z in fieldValues['8564_u']:
if 'pdf' in z:
pdfList.append(z)
fieldValues['8564_u'] = pdfList
return fieldValues
def assertFails(self, test, **kwargs):
"""
Assert that the plugin test marks the record as invalid when called with
params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertFalse(record.valid)
self.assertTrue(len(record._errors) > 0)
def assertFails(self, test, **kwargs):
"""
Assert that the plugin test marks the record as invalid when called with
params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertFalse(record.valid)
self.assertTrue(len(record.errors) > 0)
def assertOk(self, test, **kwargs):
"""
Assert that the plugin test doesn't make any modification to the record
when called with params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertTrue(record.valid)
self.assertFalse(record.amended)
self.assertEqual(len(record._amendments), 0)
self.assertEqual(len(record._errors), 0)
def assertOk(self, test, **kwargs):
"""
Assert that the plugin test doesn't make any modification to the record
when called with params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertTrue(record.valid)
self.assertFalse(record.amended)
self.assertEqual(len(record.amendments), 0)
self.assertEqual(len(record.errors), 0)
def assertAmends(self, test, changes, **kwargs):
"""
Assert that the plugin "test" amends the mock record when called with
params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertTrue(record.amended)
self.assertEqual(len(record.amendments), len(changes))
for field, val in changes.iteritems():
if val is not None:
self.assertEqual(
[((field, 0, 0), val)],
list(record.iterfield(field))
)
else:
self.assertEqual(len(list(record.iterfield(field))), 1)
def assertDeletions(self, test, deletions, **kwargs):
"""
Assert that the plugin "test" deletes from the mock record
the fields in the list 'deletions' and makes the record amended
when called with params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record)
self.assertTrue(record.amended)
self.assertEqual(len(record._amendments), len(deletions))
for field in deletions:
self.assertEqual(0, len(list(record.iterfield(field))))
if kwargs.get('tagremoved'):
self.assertFalse(record.get(kwargs.get('tagremoved')))
def assertAmends(self, test, changes, **kwargs):
"""
Assert that the plugin "test" amends the mock record when called with
params kwargs.
"""
record = AmendableRecord(MOCK_RECORD)
record.set_rule(RULE_MOCK)
test.check_record(record, **kwargs)
self.assertTrue(record.amended)
self.assertEqual(len(record._amendments), len(changes))
for field, val in changes.iteritems():
if val is not None:
self.assertEqual(((field, 0, 0), val),
list(record.iterfield(field))[0])
else:
self.assertEqual(len(list(record.iterfield(field))), 1)
def setUp(self):
""" Create a mock amenda record to test with """
self.record = AmendableRecord(MOCK_RECORD)
self.record.set_rule(RULE_MOCK)
class BibCheckAmendableRecordTest(InvenioTestCase):
""" Check the AmendableRecord class """
def setUp(self):
""" Create a mock amenda record to test with """
self.record = AmendableRecord(MOCK_RECORD)
self.record.set_rule(RULE_MOCK)
def test_valid(self):
""" Test the set_invalid method """
self.assertTrue(self.record.valid)
self.record.set_invalid("test message")
self.assertFalse(self.record.valid)
self.assertEqual(self.record.errors, ["Rule test_rule: test message"])
def test_amend(self):
""" Test the amend method """
self.assertFalse(self.record.amendments)
self.record.amend_field(("100__a", 0, 0), "Pepe", "Changed author")
self.assertEqual(self.record["100"][0][0][0][1], "Pepe")
self.assertTrue(self.record.amended)
self.assertEqual(self.record.amendments, ["Rule test_rule: Changed author"])
def test_itertags(self):
""" Test the itertags method """
self.assertEqual(
set(self.record.keys()),
set(self.record.itertags("%%%"))
)
self.assertEqual(set(['100']), set(self.record.itertags("100")))
self.assertEqual(set(['001', '005']), set(self.record.itertags("00%")))
self.assertEqual(set(), set(self.record.itertags("111")))
def test_iterfields(self):
""" Test the iterfields method """
self.assertEqual(set(), set(self.record.iterfields(["111%%%"])))
self.assertEqual(
set([(("100__a", 0, 0), "Pepe")]),
set(self.record.iterfields(["1%%%%%"]))
)
self.assertEqual(
set([(("9944_u", 0, 0), self.record["994"][0][0][0][1]),
(("9954_u", 0, 0), self.record["995"][0][0][0][1]),
(("9964_u", 0, 0), self.record["996"][0][0][0][1]),
(("9974_u", 0, 0), self.record["997"][0][0][0][1]),
(("9984_u", 0, 0), self.record["998"][0][0][0][1]),
(("9994_u", 0, 0), self.record["999"][0][0][0][1])]),
set(self.record.iterfields(["9%%%%u"]))
)
def test_is_dummy(self):
""" Test the is_dummy method """
dummy_record = {
'001': [([], ' ', ' ', '1', 1)]
}
record = AmendableRecord(dummy_record)
self.assertTrue(record.is_dummy())
ind2 = marc[4].replace('_', ' ')
sfcode = marc[5]
to_split = fields_to_split(record, tag, ind1, ind2, sfcode)
if not to_split:
continue
# work from the back to try to preserve order
positions = to_split.keys()
positions.sort(reverse=True)
for global_pos in positions:
(parts, rest_before, rest_after) = to_split[global_pos]
message += " - split %s %s" % (tag, parts)
record_delete_field(record, tag, ind1, ind2,
field_position_global=global_pos)
parts.reverse()
for subfield in parts:
field = rest_before + [subfield, ] + rest_after
record_add_field(record, tag, ind1, ind2, '', field,
field_position_global=global_pos)
if message:
record.set_amended(message)
if __name__ == '__main__':
for record in test_records:
record = AmendableRecord(get_bibrecord(record))
record.rule = {}
record.rule['name'] = 'melissa'
record.rule['holdingpen'] = False
check_record(record)
id[1][0], id[2], recid, inspire_id)
# record.warn("%s from HEPNames doesn't match id for author %s in record %s (%s)" % (id[1][0], id[2], record, inspire_id))
else:
print "email: %s, inspire-id: %s" % (id[2], id[1][0])
additions.append((id[0], 'i', id[1][0]))
if id[1][1]:
if orcid_true:
if orcid == id[1][1]:
print "%s in %s already has an ORICD" % (id[2],
recid)
else:
print "%s from HEPNames doesn't match id for author %s in record %s (%s)" % (
id[1][1], id[2], recid, orcid)
# record.warn("%s from HEPNames doesn't match id for author %s in record %s (%s)" % (id[1][1], id[2], recid, orcid))
else:
print "email: %s, orcid: %s" % (id[2], id[1][1])
additions.append((id[0], 'j', id[1][1]))
print "additions: ", additions
for addition in additions:
print "Adding %s to tag %s at position %s in %s" % (
addition[2], addition[0][0], addition[0][1], recid)
# record_add_subfield_into(record, addition[0][0], addition[1], addition[2], field_position_local=addition[0][1])
if __name__ == '__main__':
for r in test_records:
print 'working on ', r
record = AmendableRecord(get_bibrecord(r))
check_record(record)
# codes = get_fieldvalues(record, '980__a')
journals = []
dois = []
codes = []
for key, val in record.iterfields(['001___', '0247_a', '773__p', '980__a']):
if key[0] == '001___':
recid = val
if key[0] == '0247_a':
dois.append(val)
if key[0] == '773__p':
journals.append(val)
if key[0] == '980__a':
codes.append(val)
for type_code, mapping in type_codes:
if try_dict(mapping, type_code=type_code, journals=journals, dois=dois, codes=codes):
#print "Adding 980__a:%s to record %s" % (type_code, recid)
record.add_field('980__', '', subfields=[('a', type_code)])
if __name__ == '__main__':
for record in test_records:
record = AmendableRecord(get_bibrecord(record))
record.rule = {}
record.rule['name'] = 'melissa'
record.rule['holdingpen'] = False
check_record(record)
class BibCheckAmendableRecordTest(InvenioTestCase):
""" Check the AmendableRecord class """
def setUp(self):
""" Create a mock amenda record to test with """
self.record = AmendableRecord(MOCK_RECORD)
self.record.set_rule(RULE_MOCK)
def test_valid(self):
""" Test the set_invalid method """
self.assertTrue(self.record.valid)
self.record.set_invalid("test message")
self.assertFalse(self.record.valid)
self.assertEqual(len(self.record._errors), 1)
error = self.record._errors[0]
self.assertEqual(error.nature, "error")
self.assertEqual(error.rule, "test_rule")
self.assertEqual(error.msg, "test message")
def test_amend(self):
""" Test the amend method """
self.assertFalse(self.record._amendments)
self.record.amend_field(("100__a", 0, 0), "Pepe", "Changed author")
self.assertEqual(self.record["100"][0][0][0][1], "Pepe")
self.assertTrue(self.record.amended)
self.assertEqual(len(self.record._amendments), 1)
amendment = self.record._amendments[0]
self.assertEqual(amendment.nature, "amendment")
self.assertEqual(amendment.rule, "test_rule")
self.assertEqual(amendment.msg, "Changed author")
def test_itertags(self):
""" Test the itertags method """
self.assertEqual(set(self.record.keys()),
set(self.record.itertags("%%%")))
self.assertEqual(set(['100']), set(self.record.itertags("100")))
self.assertEqual(set(['001', '005']), set(self.record.itertags("00%")))
self.assertEqual(set(), set(self.record.itertags("111")))
def test_iterfields(self):
""" Test the iterfields method """
self.assertEqual(set(), set(self.record.iterfields(["111%%%"])))
self.assertEqual(set([(("100__a", 0, 0), "Pepe")]),
set(self.record.iterfields(["1%%%%%"])))
self.assertEqual(
set([(("695__a", 0, 0, 1), "gravitation: nonlocal")]),
set(
self.record.iterfields(["695__a"],
subfield_filter=('2', 'INSPIRE'))))
self.assertEqual(
set([(("696__a", 0, 1, 0), "gravitation: nonlocal")]),
set(
self.record.iterfields(["696__a"],
subfield_filter=('2', 'INSPIRE'))))
self.assertEqual(
set(),
set(
self.record.iterfields(["697__a"],
subfield_filter=('2', 'INSPIRE'))))
self.assertEqual(
set([(("698__a", 0, 0, 2), "gravitation: nonlocal"),
(("698__a", 0, 1, 2), "propagator"),
(("698__a", 0, 3, 2), "singularity")]),
set(
self.record.iterfields(["698__a"],
subfield_filter=('2', 'INSPIRE'))))
self.assertEqual(
set([(("699__a", 0, 1, 0), "gravitation"),
(("699__a", 1, 1, 0), "antigravitation")]),
set(
self.record.iterfields(["699__a"],
subfield_filter=('2', 'INSPIRE'))))
self.assertEqual(
set([(("9944_u", 0, 0), self.record["994"][0][0][0][1]),
(("9954_u", 0, 0), self.record["995"][0][0][0][1]),
(("9964_u", 0, 0), self.record["996"][0][0][0][1]),
(("9974_u", 0, 0), self.record["997"][0][0][0][1]),
(("9984_u", 0, 0), self.record["998"][0][0][0][1]),
(("9994_u", 0, 0), self.record["999"][0][0][0][1])]),
set(self.record.iterfields(["9%%%%u"])))
def test_is_dummy(self):
""" Test the is_dummy method """
dummy_record = {'001': [([], ' ', ' ', '1', 1)]}
record = AmendableRecord(dummy_record)
self.assertTrue(record.is_dummy())
