def clean_name(name_string):
good_name = None
if "f." in name_string:
born_name = name_string.split("f.")[1].strip().split("(")[0].strip()
good_name = helpers.flip_name(
name_string.split("f.")[0]) + " f. " + born_name
else:
good_name = helpers.flip_name(name_string.split("(")[0].strip())
return good_name
def isolate_name(names_string):
"""
Try isolating names and flipping names.
Expected input is a string with 'last1, first1, last2, first2...'
:param names_string: string representing depicted people
:return: list of flipped names.
:raises: ValueError if uneven number of names
"""
if not names_string:
return []
if len(names_string.split(", ")) % 2 != 0:
raise ValueError("Uneven number of names.")
# Pairwise group name parts
words = names_string.split(", ")
span = 2
grouped_names = [
", ".join(words[i:i + span]) for i in range(0, len(words), span)
]
names = []
for name_pair in grouped_names:
flipped_name = helpers.flip_name(name_pair)
names.append(flipped_name)
return names
def process_byline(entry):
"""Handle unknown entries and rearrange names."""
if 'okänd' in entry['byline'].lower():
entry['byline'] = '{{unknown}}'
elif not entry['byline']:
entry['byline'] = '{{not provided}}'
else:
entry['byline'] = helpers.flip_name(entry['byline'])
def parse_person(self, person_data):
"""Parse data about a person, e.g. in licenses."""
person = {}
person['name'] = helpers.flip_name(person_data['name'])
if person_data.get('authority') in ['KULTURNAV', 'KulturNav']:
person['k_nav'] = person_data.get('uuid')
person['role'] = self.map_person_role(person_data.get('role'))
person['id'] = person_data.get('id')
return person
def testName(namn):
if len(namn) == 0:
return None
elif namn in badNamn:
return None
elif len(namn.split(',')) not in (1, 2):
return u'För många komman i ett namn: %s' % namn
elif namn.endswith(','):
return u'Namn slutar med komma: %s' % namn
helpers.addOrIncrement(personList, helpers.flip_name(namn))
def get_person_data(self, name):
"""
Return the mapped data for a person, if any exists.
:param name: unflipped name
"""
person = helpers.flip_name(name)
mapping = self.smvk_info.mapped_and_wikidata(
person, self.smvk_info.mappings['people'])
return mapping or {'name': person}
def process_names(self):
other_names = []
if self.isPerson:
self.data["clean"]["full_name"] = self.data["first"] + \
" " + self.data["last"]
self.data["clean"]["first"] = self.data["first"].split(" ")
self.data["clean"]["last"] = self.data["last"]
else:
self.data["clean"]["full_name"] = self.data["corporate_name"]
if self.data.get("parallell_name"):
for n in helpers.flip_name(
self.data.get("parallell_name")).split(";"):
other_names.append(n)
if self.data.get("not_preferred_name"):
for n in helpers.flip_name(
self.data.get("not_preferred_name")).split(";"):
other_names.append(n)
self.data["clean"]["other_names"] = other_names
def parse_data(self, data):
"""Go through the raw data breaking out data needing mapping."""
for key, image in data.items():
self.check_for_unexpected_lists(image, image.get('photo_id'))
if image.get('event'):
self.expedition_to_match.update(
utils.clean_uncertain(common.listify(image.get('event')),
keep=True))
if image.get('museum_obj'):
museum, _, type = image.get('museum_obj').partition('/')
self.museum_to_match.add((museum, type))
if image.get('ext_ids'):
self.external_to_parse.update(image.get('ext_ids'))
# keywords - compare without case
keyword_columns = ('motivord', 'sokord')
for col in keyword_columns:
val = image.get(col) or []
val = utils.clean_uncertain(common.listify(val), keep=True)
val = [v.casefold() for v in val]
self.keywords_to_map.update(val)
# people
people_columns = ('depicted_persons', 'photographer', 'creator')
for col in people_columns:
val = image.get(col) or []
val = utils.clean_uncertain(common.listify(val), keep=True)
self.people_to_map.update(
[helpers.flip_name(person) for person in val])
# ethnic groups - compare without case
ethnic_columns = ('ethnic', 'ethnic_old')
for col in ethnic_columns:
val = image.get(col) or []
val = utils.clean_uncertain(common.listify(val), keep=True)
val = [v.casefold() for v in val]
self.ethnic_to_map.update(val)
# places
place_columns = ('land', 'region', 'ort', 'depicted_places',
('depicted_land',
'land')) # depicted_land merged with land
for col in place_columns:
key = col
if isinstance(col, tuple):
key = col[1]
col = col[0]
if key not in self.places_to_map:
self.places_to_map[key] = Counter()
val = image.get(col) or []
val = utils.clean_uncertain(common.listify(val), keep=True)
self.places_to_map[key].update(val)
def parse_creator(self, data, raw_data):
"""Parse creator info for different object types."""
data["creator"] = []
art_type = raw_data["artifactType"]
events = raw_data["eventWrap"].get("events")
if events and art_type == "Photograph":
ev_type = events[0].get("eventType")
if ev_type == "Produktion": # this is an artwork
person = self.parse_person(
raw_data["licenses"][0]["persons"][0])
data["creator"].append(person)
elif ev_type == "Fotografering": # this is a photo
related_p = [
x for x in events[0]["relatedPersons"]
if x["role"]["name"] == "Fotograf"
]
person = self.parse_person(related_p[0])
data["creator"].append(person)
elif art_type == "Thing": # this is a thing
raw_person = raw_data["media"]["pictures"][0]["photographer"]
person_name = helpers.flip_name(raw_person)
data["creator"].append({
"id": person_name,
"role": "creator",
"name": person_name
})
elif art_type == "Fineart": # this is an artwork
ev_type = events[0].get("eventType")
if ev_type == "Produksjon":
if events[0].get("relatedPersons"):
related_p = [
x for x in events[0]["relatedPersons"]
if x["role"]["name"] == "Kunstner"
]
person = self.parse_person(related_p[0])
data["creator"].append(person)
def test_flip_name_three_parts(self):
input_value = 'Last, Middle, First'
expected = 'Last, Middle, First'
self.assertEqual(flip_name(input_value), expected)
def test_flip_name_two_parts(self):
input_value = 'Last, First'
expected = 'First Last'
self.assertEqual(flip_name(input_value), expected)
def test_flip_name_one_part(self):
input_value = 'The Name'
expected = 'The Name'
self.assertEqual(flip_name(input_value), expected)
def test_flip_name_empty(self):
self.assertEqual(flip_name(''), '')
def checkLine(line, idnos):
if len(line) == 0:
return '', ''
log = []
params = line.split('|')
idno = params[0].strip()
typ = params[1].strip()
benamning = params[2].strip()
material = params[3].strip().split(',')
namn_konstnar = helpers.flip_name(params[4].strip())
namn_konstnar_knav = params[5].strip()
namn_konstruktor = [params[6].strip(), ]
namn_konstruktor_knav = params[7].strip()
namn_konstruktor.append(params[8].strip())
namn_fotograf = params[9].strip()
namn_tillverkare = [params[10].strip(), ]
namn_tillverkare.append(params[11].strip())
namn_tillverkare.append(params[12].strip())
date_foto = params[13].strip()
date_produktion = params[14].strip()
avbildad_namn = [helpers.flip_name(params[15].strip()), ]
avbildad_namn_knav = params[16].strip()
avbildad_namn.append(params[17].strip())
avbildad_namn.append(params[18].strip())
avbildad_ort = params[19].strip()
amnesord = params[20].strip().split(',')
beskrivning = params[21].strip()
motiv_amnesord = params[22].strip().split(',')
motiv_beskrivning = params[23].strip()
rattighet = params[24].strip()
samling = params[25].strip()
dimukod = params[26].strip()
# cleanup lists
material = common.trim_list(material)
namn_tillverkare = common.trim_list(namn_tillverkare)
avbildad_namn = common.trim_list(avbildad_namn)
namn_konstruktor = common.trim_list(namn_konstruktor)
amnesord = common.trim_list(amnesord)
motiv_amnesord = common.trim_list(motiv_amnesord)
# kNav
if len(namn_konstnar_knav) > 0:
addTokNavList(namn_konstnar_knav, namn_konstnar)
if len(avbildad_namn_knav) > 0:
addTokNavList(avbildad_namn_knav, avbildad_namn[0])
if len(namn_konstruktor_knav) > 0:
addTokNavList(avbildad_namn_knav,
helpers.flip_name(namn_konstruktor[0]))
log.append(testId(idno, idnos))
log.append(checkType(typ))
log.append(testRight(rattighet))
log.append(testCollection(samling))
log.append(testKeywords(amnesord, motiv_amnesord, benamning))
log.append(testDescription(beskrivning, motiv_beskrivning))
for namn in namn_tillverkare:
log.append(testName(namn))
for namn in avbildad_namn:
log.append(testName(namn))
for namn in namn_konstruktor:
log.append(testName(namn))
log.append(testName(namn_fotograf))
log.append(testName(namn_konstnar))
log.append(testName(namn_fotograf))
log.append(testDateRange(date_foto))
log.append(testDateRange(date_produktion))
# test filenames
log.append(
testNameGeneration(idno, typ, benamning, motiv_beskrivning,
avbildad_namn, avbildad_ort, date_foto,
date_produktion))
# some counters
if len(avbildad_ort) > 0:
helpers.addOrIncrement(ortList, avbildad_ort)
for m in material:
helpers.addOrIncrement(materialList, m.lower())
if len(benamning) > 0:
helpers.addOrIncrement(benamningList, benamning.lower())
# compile and return
logtext = ''
for l in log:
if l:
logtext += u'%s. ' % l
return idno, logtext.strip()
def make_item_from_raw(entry, smm_info):
"""
Given the raw metadata for an item, construct an SMMItem.
@param entry: the raw metadata entry as a dict
@param smm_info: the parent smm_info instance
@return: SMMItem
"""
d = {}
# map to internal labels and flip names
d['idno'] = entry[u'Identifikationsnr']
d['typ'] = entry[u'Typ av objekt']
d['benamning'] = entry[u'Benämning']
d['material'] = entry[u'Material']
d['namn_konstnar'] = helpers.flip_name(entry[u'Namn-Konstnär'])
namn_konstnar_knav = entry[u'Konstnär-KulturNav']
d['namn_konstruktor'] = helpers.flip_names(entry[u'Namn-Konstruktör'])
namn_konstruktor_knav = entry[u'Konstruktör-KulturNav']
d['namn_fotograf'] = helpers.flip_name(entry[u'Namn-Fotograf'])
d['namn_tillverkare'] = helpers.flip_names(entry[u'Namn-Tillverkare'])
d['date_foto'] = entry[u'Datering-Fotografering']
d['date_produktion'] = entry[u'Datering-Produktion']
avbildad_namn = entry[u'Avbildade namn']
avbildad_namn_knav = entry[u'Avbildade-KulturNav']
d['avbildad_ort'] = entry[u'Avbildade - orter']
d['amnesord'] = entry[u'Ämnesord']
d['beskrivning'] = entry[u'Beskrivning']
d['motiv_amnesord'] = entry[u'Motiv-ämnesord']
d['motiv_beskrivning'] = entry[u'Motiv-beskrivning']
d['rattighet'] = entry[u'Rättigheter']
d['samling'] = entry[u'Samling']
d['dimukod'] = entry[u'Dimukode']
# handle kulturNav
if namn_konstnar_knav:
smm_info.add_to_k_nav_list(namn_konstnar_knav, d['namn_konstnar'])
if namn_konstruktor_knav:
smm_info.add_to_k_nav_list(namn_konstruktor_knav,
d['namn_konstruktor'][0])
if avbildad_namn_knav:
smm_info.add_to_k_nav_list(avbildad_namn_knav,
helpers.flip_name(avbildad_namn[0]))
# split avbildad_namn into people and ships/boat types
# a person is anyone with a name like Last, First
d['avbildad_person'] = []
d['avbildat_fartyg'] = []
for a in avbildad_namn:
if a != helpers.flip_name(a):
d['avbildad_person'].append(helpers.flip_name(a))
else:
d['avbildat_fartyg'].append(a)
# add to dict, now with flipped names
d['avbildad_namn'] = d['avbildad_person'] + d['avbildat_fartyg']
# cleanup lists
d['avbildad_person'] = common.trim_list(d['avbildad_person'])
d['avbildat_fartyg'] = common.trim_list(d['avbildat_fartyg'])
d['avbildad_namn'] = common.trim_list(d['avbildad_namn'])
# cleanup blacklisted
if d['date_foto'].strip('.').lower() in smm_info.bad_date:
d['date_foto'] = ''
if d['date_produktion'].strip('.').lower() in smm_info.bad_date:
d['date_produktion'] = ''
if d['namn_konstnar'].lower() in smm_info.bad_namn:
d['namn_konstnar'] = ''
if d['namn_fotograf'].lower() in smm_info.bad_namn:
d['namn_fotograf'] = ''
return SMMItem(d)