def marc21_to_edition_statement(self, key, value):
"""Get edition statement data.
editionDesignation: 250 [$a non repetitive] (without trailing /)
responsibility: 250 [$b non repetitive]
"""
key_per_code = {'a': 'editionDesignation', 'b': 'responsibility'}
def build_edition_data(code, label, index, link):
data = [{'value': remove_trailing_punctuation(label)}]
try:
alt_gr = marc21.alternate_graphic['250'][link]
subfield = \
marc21.get_subfields(alt_gr['field'])[index]
data.append({
'value': remove_trailing_punctuation(subfield),
'language': get_language_script(alt_gr['script'])
})
except Exception as err:
pass
return data
tag_link, link = get_field_link_data(value)
items = get_field_items(value)
index = 1
edition_data = {}
subfield_selection = {'a', 'b'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
subfield_selection.remove(blob_key)
edition_data[key_per_code[blob_key]] = \
build_edition_data(blob_key, blob_value, index, link)
if blob_key != '__order__':
index += 1
return edition_data or None
def build_statement(field_value, ind2):
def build_place_or_agent_data(code, label):
type_per_code = {'a': 'bf:Place', 'b': 'bf:Agent'}
return {'type': type_per_code[code], 'label': [{'value': value}]} \
if (value := remove_trailing_punctuation(label)) else None
# function build_statement start here
statement = []
items = get_field_items(field_value)
for blob_key, blob_value in items:
if blob_key in ('a', 'b'):
place_or_agent_data = build_place_or_agent_data(
blob_key, blob_value)
if place_or_agent_data:
statement.append(place_or_agent_data)
return statement or None
def unimarc_series_statement(self, key, value):
"""Get seriesStatement.
series.name: [225$a repetitive]
series.number: [225$v repetitive]
"""
# normalize the value by building couple of $a, $v
# $v can be missing in a couple
items = get_field_items(value)
new_data = []
fist_a_value = None
pending_v_values = []
subfield_selection = {'a', 'e', 'i', 'v'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
if blob_key == 'a':
fist_a_value = blob_value
try:
subfield_selection.remove('a')
except KeyError:
pass
elif blob_key == 'e':
fist_a_value += ': ' + blob_value
elif blob_key == 'i':
# we keep on the $e associeted to the $a
try:
subfield_selection.remove('e')
except KeyError:
pass
if fist_a_value:
new_data.append(('a', fist_a_value))
for v_value in pending_v_values:
new_data.append(('v', v_value))
fist_a_value = None
pending_v_values = []
new_data.append(('a', blob_value))
elif blob_key == 'v':
pending_v_values.append(blob_value)
if fist_a_value:
new_data.append(('a', fist_a_value))
for v_value in pending_v_values:
new_data.append(('v', v_value))
new_value = GroupableOrderedDict(tuple(new_data))
unimarc.extract_series_statement_from_marc_field(key, new_value, self)
def marc21_to_edition_statement(self, key, value):
"""Get edition statement data.
editionDesignation: 250 [$a non repetitive] (without trailing /)
responsibility: 250 [$b non repetitive]
"""
key_per_code = {'a': 'editionDesignation', 'b': 'responsibility'}
tag_link, link = get_field_link_data(value)
items = get_field_items(value)
index = 1
edition_data = {}
subfield_selection = {'a', 'b'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
subfield_selection.remove(blob_key)
edition_data[key_per_code[blob_key]] = \
marc21.build_value_with_alternate_graphic(
'250', blob_key, blob_value, index, link, ',.', ':;/-=')
if blob_key != '__order__':
index += 1
return edition_data or None
def marc21_to_summary(self, key, value):
"""Get summary from repetitive field 520."""
key_per_code = {'a': 'label', 'c': 'source'}
# parse field 520 subfields for extracting:
# summary and source parts
tag_link, link = get_field_link_data(value)
items = get_field_items(value)
index = 1
summary = {}
subfield_selection = {'a', 'c'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
subfield_selection.remove(blob_key)
if blob_key == 'a':
summary_data = marc21.build_value_with_alternate_graphic(
'520', blob_key, blob_value, index, link, ',.', ':;/-=')
else:
summary_data = blob_value
if summary_data:
summary[key_per_code[blob_key]] = summary_data
if blob_key != '__order__':
index += 1
return summary or None
def add_author_to_subfield_t(value):
"""Get author from subfield_t and add it to subfield_t.
The form 'lastname, firstname' of the author form subfield a
is a appended to the subfield_t in the following form:
' / firstname lastname'
"""
items = get_field_items(value)
new_data = []
author = None
pending_g_values = []
pending_v_values = []
match = re.compile(r'\. -$') # match the trailing '. -'
subfield_selection = {'a', 't', 'g', 'v'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
if blob_key == 'a':
# remove the trailing '. -'
author = match.sub('', blob_value)
# reverse first name and last name
author_parts = author.split(',')
author = ' '.join(reversed(author_parts)).strip()
subfield_selection.remove('a')
elif blob_key == 't':
subfield_t = blob_value
if author:
subfield_t += ' / ' + author
new_data.append(('t', subfield_t))
elif blob_key == 'g':
pending_g_values.append(blob_value)
elif blob_key == 'v':
pending_v_values.append(blob_value)
for g_value in pending_g_values:
new_data.append(('g', g_value))
for v_value in pending_v_values:
new_data.append(('v', v_value))
return GroupableOrderedDict(tuple(new_data))
def build_statement(field_value, ind2):
def build_agent_data(code, label, index, link):
type_per_code = {'a': 'bf:Place', 'b': 'bf:Agent'}
agent_data = {
'type': type_per_code[code],
'label': [{
'value': remove_trailing_punctuation(label)
}]
}
try:
alt_gr = marc21.alternate_graphic['264'][link]
subfield = \
marc21.get_subfields(alt_gr['field'])[index]
agent_data['label'].append({
'value':
remove_trailing_punctuation(subfield),
'language':
marc21.get_language_script(alt_gr['script'])
})
except Exception as err:
pass
return agent_data
# function build_statement start here
tag_link, link = get_field_link_data(field_value)
items = get_field_items(field_value)
statement = []
index = 1
for blob_key, blob_value in items:
if blob_key in ('a', 'b'):
agent_data = build_agent_data(blob_key, blob_value, index,
link)
statement.append(agent_data)
if blob_key != '__order__':
index += 1
return statement
def unimarc_title(self, key, value):
"""Get title data.
field 200: non repetitive
$a : repetitive
$e : repetitive
$f : repetitive
$g : repetitive
$h : repetitive
$i : repetitive
field 510,512,514,515,516,517,518,519,532: repetitive
$a : non repetitive
$e : repetitive
$h : repetitive
$i : repetitive
"""
title_list = []
title = self.get('title', [])
# this function will be called for each fields 200, but as we already
# process all of them in the first run and the tittle is already build,
# there is nothing to do if the title has already been build.
if not title:
language = unimarc.lang_from_101
responsibilites = []
for tag in [
'200', '510', '512', '514', '515', '516', '517', '518', '519',
'532'
]:
for field in unimarc.get_alt_graphic_fields(tag=tag):
title_data = {}
part_list = TitlePartList(part_number_code='h',
part_name_code='i')
subfields_6 = unimarc.get_subfields(field, '6')
subfields_7 = unimarc.get_subfields(field, '7')
subfields_a = unimarc.get_subfields(field, 'a')
subfields_e = unimarc.get_subfields(field, 'e')
language_script_code = ''
if subfields_7:
language_script_code = \
unimarc.get_language_script(subfields_7[0])
title_type = 'bf:VariantTitle'
if tag == '200':
title_type = 'bf:Title'
elif tag == '510':
title_type = 'bf:ParallelTitle'
# build title parts
index = 1
link = ''
if subfields_6:
link = subfields_6[0]
items = get_field_items(field['subfields'])
for blob_key, blob_value in items:
if blob_key == 'a':
value_data = \
unimarc.build_value_with_alternate_graphic(
tag, blob_key, blob_value,
index, link, ',.', ':;/-=')
title_data['mainTitle'] = value_data
if blob_key == 'e':
value_data = \
unimarc.build_value_with_alternate_graphic(
tag, blob_key, blob_value,
index, link, ',.', ':;/-=')
title_data['subtitle'] = value_data
if blob_key in ['f', 'g'] and tag == '200':
value_data = \
unimarc.build_value_with_alternate_graphic(
tag, blob_key, blob_value,
index, link, ',.', ':;/-=')
responsibilites.append(value_data)
if blob_key in ['h', 'i']:
part_list.update_part([dict(value=blob_value)],
blob_key, blob_value)
if blob_key != '__order__':
index += 1
title_data['type'] = title_type
the_part_list = part_list.get_part_list()
if the_part_list:
title_data['part'] = the_part_list
if title_data:
title_list.append(title_data)
# extract responsibilities
if responsibilites:
new_responsibility = self.get('responsibilityStatement', [])
for resp in responsibilites:
new_responsibility.append(resp)
self['responsibilityStatement'] = new_responsibility
return title_list or None
def unimarc_publishers_provision_activity_publication(self, key, value):
"""Get provision activity dates."""
def build_place_or_agent_data(code, label, index):
type_per_code = {'a': 'bf:Place', 'c': 'bf:Agent'}
place_or_agent_data = {
'type': type_per_code[code],
'label': [{
'value': remove_trailing_punctuation(label)
}]
}
return place_or_agent_data
def build_place():
# country from 102
place = {}
field_102 = unimarc.get_fields(tag='102')
if field_102:
field_102 = field_102[0]
country_codes = unimarc.get_subfields(field_102, 'a')
if country_codes:
place['country'] = country_codes[0].lower()
place['type'] = 'bf:Place'
return place
publication = {}
ind2 = key[4]
type_per_ind2 = {
' ': 'bf:Publication',
'_': 'bf:Publication',
'0': 'bf:Publication',
'1': 'bf:Production',
'2': 'bf:Distribution',
'3': 'bf:Manufacture'
}
if ind2 == '4':
field_d = value.get('d')
if field_d:
field_d = force_list(field_d)[0]
copyright_date = self.get('copyrightDate', [])
if field_d[0] == 'P':
copyright_date.append('℗ ' + field_d[2:])
else:
copyright_date.append('© ' + field_d)
self['copyrightDate'] = copyright_date
else:
publication = {
'type': type_per_ind2[ind2],
'statement': [],
}
statement = []
items = get_field_items(value)
index = 1
for blob_key, blob_value in items:
if blob_key in ('a', 'c'):
place_or_agent_data = build_place_or_agent_data(
blob_key, blob_value, index)
statement.append(place_or_agent_data)
if blob_key != '__order__':
index += 1
if statement:
publication['statement'] = statement
if ind2 in (' ', '_', '0'):
place = build_place()
if place:
publication['place'] = [place]
subfields_d = utils.force_list(value.get('d'))
if subfields_d:
subfield_d = subfields_d[0]
publication['statement'].append({
'label': [{
'value': subfield_d
}],
'type': 'Date'
})
if ind2 in (' ', '_', '0'):
dates = subfield_d.replace('[', '').replace(']', '').split('-')
try:
start_date = make_year(dates[0])
if start_date:
publication['startDate'] = start_date
except Exception:
pass
try:
end_date = make_year(dates[1])
if end_date:
publication['endDate'] = end_date
except Exception:
pass
if not publication.get('statement'):
publication = None
return publication or None
def marc21_to_title(self, key, value):
"""Get title data.
The title data are extracted from the following fields:
field 245:
$a : non repetitive
$b : non repetitive
$c : non repetitive
$n : repetitive
$p : repetitive
$6 : non repetitive
field 246:
$a : non repetitive
$n : repetitive
$p : repetitive
$6 : non repetitive
"""
# extraction and initialization of data for further processing
subfield_245_a = ''
subfield_245_b = ''
fields_245 = marc21.get_fields(tag='245')
if fields_245:
subfields_245_a = marc21.get_subfields(fields_245[0], 'a')
subfields_245_b = marc21.get_subfields(fields_245[0], 'b')
if subfields_245_a:
subfield_245_a = subfields_245_a[0]
if subfields_245_b:
subfield_245_b = subfields_245_b[0]
field_245_a_end_with_equal = re.search(r'\s*=\s*$', subfield_245_a)
field_245_a_end_with_colon = re.search(r'\s*:\s*$', subfield_245_a)
field_245_a_end_with_semicolon = re.search(r'\s*;\s*$', subfield_245_a)
field_245_b_contains_equal = re.search(r'=', subfield_245_b)
fields_246 = marc21.get_fields(tag='246')
subfield_246_a = ''
if fields_246:
subfields_246_a = marc21.get_subfields(fields_246[0], 'a')
if subfields_246_a:
subfield_246_a = subfields_246_a[0]
tag_link, link = get_field_link_data(value)
items = get_field_items(value)
index = 1
title_list = []
title_data = {}
part_list = TitlePartList(part_number_code='n', part_name_code='p')
parallel_titles = []
pararalel_title_data_list = []
pararalel_title_string_set = set()
responsibility = {}
# parse field 245 subfields for extracting:
# main title, subtitle, parallel titles and the title parts
subfield_selection = {'a', 'b', 'c', 'n', 'p'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
value_data = marc21.build_value_with_alternate_graphic(
'245', blob_key, blob_value, index, link, ',.', ':;/-=')
if blob_key in {'a', 'b', 'c'}:
subfield_selection.remove(blob_key)
if blob_key == 'a':
if value_data:
title_data['mainTitle'] = value_data
elif blob_key == 'b':
if subfield_246_a:
subtitle, parallel_titles, pararalel_title_string_set = \
extract_subtitle_and_parallel_titles_from_field_245_b(
value_data, field_245_a_end_with_equal)
if subtitle:
title_data['subtitle'] = subtitle
elif not subfield_246_a and value_data:
title_data['subtitle'] = value_data
elif blob_key == 'c':
responsibility = build_responsibility_data(value_data)
elif blob_key in ['n', 'p']:
part_list.update_part(value_data, blob_key, blob_value)
if blob_key != '__order__':
index += 1
title_data['type'] = 'bf:Title'
the_part_list = part_list.get_part_list()
if the_part_list:
title_data['part'] = the_part_list
if title_data:
title_list.append(title_data)
for parallel_title in parallel_titles:
title_list.append(parallel_title)
# extract variant titles
variant_title_list = \
marc21.build_variant_title_data(pararalel_title_string_set)
for variant_title_data in variant_title_list:
title_list.append(variant_title_data)
# extract responsibilities
if responsibility:
new_responsibility = self.get('responsibilityStatement', [])
for resp in responsibility:
new_responsibility.append(resp)
self['responsibilityStatement'] = new_responsibility
return title_list or None
def marc21_to_classification(self, key, value):
"""Get classification and subject from 980."""
classification_type_per_tag = {
'050': 'bf:ClassificationLcc',
'060': 'bf:ClassificationNlm',
'080': 'bf:ClassificationUdc',
'082': 'bf:ClassificationDdc',
}
def get_classif_type_and_subdivision_codes_from_980_2(subfield_2):
classification_type_per_tag_980_2 = {
'brp': 'classification_brunetparguez',
'dr-sys': 'classification_droit',
'musi': 'classification_musicale_instruments',
'musg': 'classification_musicale_genres'
}
subdivision_subfield_codes_per_tag_980_2 = {
'brp': {'d'},
'musg': {'d', 'e'}
}
classification_type = None
subdivision_subfield_codes = None
for key in classification_type_per_tag_980_2:
regexp = re.compile(r'{key}'.format(key=key), re.IGNORECASE)
if regexp.search(subfield_2):
classification_type = classification_type_per_tag_980_2[key]
if key in subdivision_subfield_codes_per_tag_980_2:
subdivision_subfield_codes = \
subdivision_subfield_codes_per_tag_980_2[key]
break
return classification_type, subdivision_subfield_codes
tag = key[:3]
indicator1 = key[3]
indicator2 = key[4]
subfields_a = utils.force_list(value.get('a', []))
subfields_2 = utils.force_list(value.get('2'))
subfield_2 = None
if subfields_2:
subfield_2 = subfields_2[0]
for subfield_a in subfields_a:
classification = {}
classification['classificationPortion'] = subfield_a
if tag == '980':
contains_factum_regexp = re.compile(r'factum')
match = contains_factum_regexp.search(subfield_2)
if match:
subject = {
'type': 'bf:Person',
'preferred_name': subfield_a,
'source': 'Factum'
}
subjects = self.get('subjects', [])
subjects.append(subject)
self['subjects'] = subjects
classif_type, subdivision_subfield_codes = \
get_classif_type_and_subdivision_codes_from_980_2(subfield_2)
if classif_type:
classification['type'] = classif_type
if subdivision_subfield_codes:
items = get_field_items(value)
subdivision = []
for blob_key, blob_value in items:
if blob_key in subdivision_subfield_codes:
subdivision.append(blob_value)
if subdivision:
classification['subdivision'] = subdivision
else: # avoid classification if type not found
classification = None
else:
classification['type'] = classification_type_per_tag[tag]
if tag == '050' and indicator2 == '0':
classification['assigner'] = 'LOC'
if tag == '060' and indicator2 == '0':
classification['assigner'] = 'NLM'
if tag == '080':
subfields_x = utils.force_list(value.get('x'))
if subfields_x:
classification['subdivision'] = []
for subfield_x in subfields_x:
classification['subdivision'].append(subfield_x)
edition = None
if indicator1 == '0':
edition = 'Full edition'
elif indicator1 == '1':
edition = 'Abridged edition'
if subfield_2:
if edition:
edition += ', ' + subfield_2
else:
edition = subfield_2
if edition:
classification['edition'] = edition
elif tag == '082':
subfields_q = utils.force_list(value.get('q'))
subfield_q = None
edition = None
if subfields_q:
subfield_q = subfields_q[0]
if indicator2 == '0':
classification['assigner'] = 'LOC'
elif subfield_q:
classification['assigner'] = subfield_q
if indicator1 == '0':
edition = 'Full edition'
elif indicator1 == '1':
edition = 'Abridged edition'
if subfield_2:
if edition:
edition += ', ' + subfield_2
else:
edition = subfield_2
if edition:
classification['edition'] = edition
classification_list = self.get('classification', [])
if classification:
classification_list.append(classification)
self['classification'] = classification_list
subfield_245_a = subfields_245_a[0]
if subfields_245_b:
subfield_245_b = subfields_245_b[0]
field_245_a_end_with_equal = re.search(r'\s*=\s*$', subfield_245_a)
field_245_a_end_with_colon = re.search(r'\s*:\s*$', subfield_245_a)
field_245_a_end_with_semicolon = re.search(r'\s*;\s*$', subfield_245_a)
field_245_b_contains_equal = re.search(r'=', subfield_245_b)
fields_246 = marc21.get_fields(tag='246')
subfield_246_a = ''
if fields_246:
if subfields_246_a := marc21.get_subfields(fields_246[0], 'a'):
subfield_246_a = subfields_246_a[0]
tag_link, link = get_field_link_data(value)
items = get_field_items(value)
index = 1
title_list = []
title_data = {}
part_list = TitlePartList(part_number_code='n', part_name_code='p')
parallel_titles = []
pararalel_title_data_list = []
pararalel_title_string_set = set()
responsibility = {}
subfield_selection = {'a', 'b', 'c', 'n', 'p'}
for blob_key, blob_value in items:
if blob_key in subfield_selection:
value_data = marc21.build_value_with_alternate_graphic(
'245', blob_key, blob_value, index, link, ',.', ':;/-=')
if blob_key in {'a', 'b', 'c'}:
def unimarc_publishers_provision_activity_publication(self, key, value):
"""Get provision activity dates."""
def build_place_or_agent_data(code, label, index):
type_per_code = {
'a': 'bf:Place',
'c': 'bf:Agent',
'e': 'bf:Place',
'g': 'bf:Agent'
}
place_or_agent_data = {
'type': type_per_code[code],
'label': [{'value': remove_trailing_punctuation(label)}]
}
return place_or_agent_data
def build_place():
# country from 102
place = {}
field_102 = unimarc.get_fields(tag='102')
if field_102:
field_102 = field_102[0]
country_codes = unimarc.get_subfields(field_102, 'a')
if country_codes:
country = _COUNTRY_UNIMARC_MARC21.get(country_codes[0])
if country:
place['country'] = country
place['type'] = 'bf:Place'
return place
# only take 214 if exists
publication = {}
ind2 = key[4]
type_per_ind2 = {
' ': 'bf:Publication',
'_': 'bf:Publication',
'0': 'bf:Publication',
'1': 'bf:Production',
'2': 'bf:Distribution',
'3': 'bf:Manufacture'
}
if ind2 == '4':
field_d = value.get('d')
if field_d:
field_d = utils.force_list(field_d)[0]
copyright_date = self.get('copyrightDate', [])
if field_d[0] == 'P':
copyright_date.append('℗ ' + field_d[2:])
else:
copyright_date.append('© ' + field_d)
self['copyrightDate'] = copyright_date
else:
start_date = None
end_date = None
place = build_place()
field_100 = unimarc.get_fields('100')
if field_100:
field_100 = field_100[0]
subfield_a = unimarc.get_subfields(field_100, 'a')
if subfield_a:
subfield_a = subfield_a[0]
start_date = make_year(subfield_a[9:13])
end_date = make_year(subfield_a[14:17])
if key[:3] == '210':
if not unimarc.get_fields(tag='214'):
publications = self.setdefault('provisionActivity', [])
items = get_field_items(value)
index = 1
publication = {}
statement = []
for blob_key, blob_value in items:
if blob_key in ('a', 'c'):
type = 'bf:Publication'
if index == 1:
old_type = 'bf:Publication'
publication = {'type': type, 'statement': []}
if type != old_type:
subfields_h = utils.force_list(value.get('h'))
publication['statement'] = statement
if subfields_h:
subfields_h = subfields_h[0]
publication['statement'].append({
'label': [{'value': subfields_h}],
'type': 'Date'
})
statement = []
publications.append(publication)
publication = {
'type': type,
'statement': [],
}
old_type = type
place_or_agent_data = build_place_or_agent_data(
blob_key, blob_value, index)
statement.append(place_or_agent_data)
if blob_key in ('e', 'g'):
type = 'bf:Manufacture'
if index == 1:
old_type = 'bf:Manufacture'
publication = {'type': type, 'statement': []}
if type != old_type:
subfields_d = utils.force_list(value.get('d'))
publication['statement'] = statement
if subfields_d:
subfield_d = subfields_d[0]
publication['statement'].append({
'label': [{'value': subfield_d}],
'type': 'Date'
})
if start_date:
publication['startDate'] = start_date
if end_date:
publication['endDate'] = end_date
if place:
publication['place'] = [place]
statement = []
publications.append(publication)
publication = {
'type': type,
'statement': [],
}
old_type = type
place_or_agent_data = build_place_or_agent_data(
blob_key, blob_value, index)
statement.append(place_or_agent_data)
if blob_key != '__order__':
index += 1
if statement:
publication = {
'type': type,
'statement': statement,
}
date_subfield = 'd'
if type == 'bf:Manufacture':
date_subfield = 'h'
subfields = utils.force_list(value.get(date_subfield))
if subfields:
subfield = subfields[0]
publication['statement'].append({
'label': [{'value': subfield}],
'type': 'Date'
})
if publication['type'] == 'bf:Publication':
if start_date:
publication['startDate'] = start_date
if end_date:
publication['endDate'] = end_date
if place:
publication['place'] = [place]
publications.append(publication)
if publications:
self['provisionActivity'] = publications
return None
else:
publication = {
'type': type_per_ind2[ind2],
'statement': [],
}
statement = []
items = get_field_items(value)
index = 1
for blob_key, blob_value in items:
if blob_key in ('a', 'c'):
place_or_agent_data = build_place_or_agent_data(
blob_key, blob_value, index)
statement.append(place_or_agent_data)
if blob_key != '__order__':
index += 1
if statement:
publication['statement'] = statement
if publication['type'] == 'bf:Publication':
if place:
publication['place'] = [place]
subfields_d = utils.force_list(value.get('d'))
if subfields_d:
subfield_d = subfields_d[0]
publication['statement'].append({
'label': [{'value': subfield_d}],
'type': 'Date'
})
if publication['type'] == 'bf:Publication':
if start_date:
publication['startDate'] = start_date
if end_date:
publication['endDate'] = end_date
if not publication.get('statement'):
publication = None
return publication or None
def marc21_to_work_access_point(self, key, value):
"""Get work access point."""
"""
* "date_of_work": "[130$f|730$f]"
* "miscellaneous_information": "[130$g|130$s|730$g|730$s]"
* "language": "[130$l|730$l]"
* "form_subdivision": ["[130$k|730$k]"]
* "medium_of_performance_for_music": ["[130$m|730$m]"]
* "arranged_statement_for_music": "[130$o|730$o]"
* "key_for_music": "[130$r|730$r]"
[1] Nettoyer la chaîne: supprimer la ponctuation finale "/:;.,=",
supprimer en particulier la chaine ". - "
"""
work = {}
tag_key = key[:3]
part_list = TitlePartList(part_number_code='n', part_name_code='p')
part_selection = {'n', 'p'}
items = get_field_items(value)
if tag_key in ['130', '730']:
work_selection = {'a', 'f', 'k', 'l', 'm', 'o', 'r'}
miscellaneous_selection = {'g', 's'}
miscellaneous_parts = []
# _WORK_ACCESS_POINT.get(subfield_code)
for blob_key, blob_value in items:
if blob_key in work_selection:
if blob_key in {'k', 'm'}:
datas = work.get(_WORK_ACCESS_POINT.get(blob_key), [])
datas.append(blob_value)
work[_WORK_ACCESS_POINT.get(blob_key)] = datas
else:
work[_WORK_ACCESS_POINT.get(blob_key)] = blob_value
if blob_key in miscellaneous_selection:
miscellaneous_parts.append(blob_value)
if blob_key in part_selection:
part_list.update_part(blob_value, blob_key, blob_value)
if miscellaneous_parts:
work['miscellaneous_information'] = '. '.join(miscellaneous_parts)
if tag_key == '240':
for blob_key, blob_value in items:
if blob_key in {'a'}:
# work[_WORK_ACCESS_POINT.get('a')] = value.get('a')
work[_WORK_ACCESS_POINT.get(blob_key)] = blob_value
if blob_key in part_selection:
part_list.update_part(blob_value, blob_key, blob_value)
field_100 = marc21.get_fields('100')
if field_100:
agent = {}
for blob_key, blob_value in field_100[0].get('subfields').items():
agent['type'] = 'bf:Person'
if blob_key == 'a':
# numeration = not_repetitive(
# marc21.bib_id, marc21.bib_id, blob_key, blob_value, 'b')
agent['preferred_name'] = remove_trailing_punctuation(
blob_value)
if blob_key == 'b':
# numeration = not_repetitive(
# marc21.bib_id, marc21.bib_id, blob_key, blob_value, 'b')
agent['numeration'] = remove_trailing_punctuation(
blob_value)
if blob_key == 'c':
# qualifier = not_repetitive(
# marc21.bib_id, marc21.bib_id, blob_key, blob_value, 'c')
agent['qualifier'] = remove_trailing_punctuation(
blob_value)
if blob_key == 'd':
# date = not_repetitive(
# marc21.bib_id, marc21.bib_id, blob_key, blob_value, 'd')
date = blob_value.rstrip(',')
dates = remove_trailing_punctuation(date).split('-')
try:
date_of_birth = dates[0].strip()
if date_of_birth:
agent['date_of_birth'] = date_of_birth
except Exception:
pass
try:
date_of_death = dates[1].strip()
if date_of_death:
agent['date_of_death'] = date_of_death
except Exception:
pass
if blob_key == 'q':
# fuller_form_of_name = not_repetitive(
# marc21.bib_id, marc21.bib_id, blob_key, blob_value, 'q')
agent['fuller_form_of_name'] = remove_trailing_punctuation(
blob_value).lstrip('(').rstrip(')')
work['agent'] = agent
the_part_list = part_list.get_part_list()
if the_part_list:
work['part'] = the_part_list
if work:
work_access_points = self.get('work_access_point', [])
work_access_points.append(work)
self['work_access_point'] = work_access_points
