def test_name_set_no_changes(self):
"""
Tests that the field name does not change for creating a new one
"""
field1 = basic.lookup(['AB1', 'CD2', 'EF3'], name='field1')
field2 = basic.lookup(['AB1', 'CD2', 'EF3'], name='field2')
self.assertEqual('field1', field1.name)
self.assertEqual('field2', field2.name)
def test_name_set_no_changes(self):
"""
Tests that the field name does not change for creating a new one
"""
field1 = basic.lookup(('AB1', 'CD2', 'EF3'), columns=3, name='field1')
field2 = basic.lookup(('AB1', 'CD2', 'EF3'), columns=3, name='field2')
self.assertEqual('field1', field1.name)
self.assertEqual('field2', field2.name)
def test_name_default(self):
"""
Tests that the default field name is correct for optional fields.
"""
field = basic.lookup(['AB1', 'CD2', 'EF3'])
self.assertEqual('Lookup Field', field.name)
def society(name=None, compulsory=False):
"""
Society ID field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Society ID field rules
"""
if name is None:
name = 'Society ID Field'
codes = _tables.society_codes()
for code in codes:
if len(code) > 1 and code[0] == '0':
codes.append(code[1:])
if len(code) > 2 and code[1] == '0':
codes.append(code[2:])
society_field = basic.lookup(_tables.society_codes(),
columns=_config.field_size('table', 'society'), compulsory=compulsory,
name=name)
society_field.setParseAction(lambda c: None if c[0] is None else int(c[0]))
society_field = society_field.setResultsName('society')
return society_field
def test_name_default(self):
"""
Tests that the default field name is correct for optional fields.
"""
field = basic.lookup(['AB1', 'CD2', 'EF3'])
self.assertEqual('Lookup Field', field.name)
def test_name_default_compulsory(self):
"""
Tests that the default field name is correct for optional fields, for compulsory fields.
"""
field = basic.lookup(('AB1', 'CD2', 'EF3'), columns=3, compulsory=True)
self.assertEqual('Lookup Field', field.name)
def test_name_set(self):
"""
Tests that the given field name is set correctly for optional fields.
"""
name = "Field Name"
field = basic.lookup(['AB1', 'CD2', 'EF3'], name=name)
self.assertEqual(name, field.name)
def test_name_set(self):
"""
Tests that the given field name is set correctly for optional fields.
"""
name = "Field Name"
field = basic.lookup(['AB1', 'CD2', 'EF3'], name=name)
self.assertEqual(name, field.name)
def test_name_set_compulsory(self):
"""
Tests that the given field name is set correctly for optional fields, for compulsory fields.
"""
name = "Field Name"
field = basic.lookup(('AB1', 'CD2', 'EF3'), columns=3, name=name, compulsory=True)
self.assertEqual(name, field.name)
def filename_version(values, name=None):
field = lookup(values, name)
default_version = CWRConfiguration().default_version()
# Parse action
field.addParseAction(lambda n: default_version)
return field
def filename_version(values, name=None):
field = lookup(values, name)
default_version = CWRConfiguration().default_version()
# Parse action
field.addParseAction(lambda n: default_version)
return field
def lookup_int(values, name=None):
"""
Lookup field which transforms the result into an integer.
:param values: values allowed
:param name: name for the field
:return: grammar for the lookup field
"""
field = basic.lookup(values, name)
field.addParseAction(lambda l: int(l[0]))
return field
def lookup_int(values, name=None):
"""
Lookup field which transforms the result into an integer.
:param values: values allowed
:param name: name for the field
:return: grammar for the lookup field
"""
field = basic.lookup(values, name)
field.addParseAction(lambda l: int(l[0]))
return field
def work_type(name=None, compulsory=False):
"""
Work Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Work Type field rules
"""
if name is None:
name = 'Work Type'
work_type_field = basic.lookup(_tables.work_types(), columns=_config.field_size('table', 'work_type'),
compulsory=compulsory, name=name)
work_type_field = work_type_field.setResultsName('cwr_work_type')
return work_type_field
def types_of_right(name=None, compulsory=False):
"""
Types of Right field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Types of Right field rules
"""
if name is None:
name = 'Type of Right'
types_of_right_field = basic.lookup(_tables.type_of_rights(),
columns=_config.field_size('table', 'type_of_right'),
compulsory=compulsory, name=name)
types_of_right_field = types_of_right_field.setResultsName('type_of_right')
return types_of_right_field
def record_types(name=None, compulsory=False):
"""
Record Types field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Record Types field rules
"""
if name is None:
name = 'Record Type'
record_type_field = basic.lookup(_tables.record_types(),
columns=_config.field_size('table', 'record_type'),
compulsory=compulsory, name=name)
record_type_field = record_type_field.setResultsName('record_type')
return record_type_field
def message_levels(name=None, compulsory=False):
"""
Message Levels field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Message Levels field rules
"""
if name is None:
name = 'Message Level'
message_level_field = basic.lookup(_tables.message_levels(),
columns=_config.field_size('table', 'message_level'),
compulsory=compulsory, name=name)
message_level_field = message_level_field.setResultsName('message_level')
return message_level_field
def instruments(name=None, compulsory=False):
"""
Instruments field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Instruments field rules
"""
if name is None:
name = 'Instrument'
instruments_field = basic.lookup(_tables.instruments(),
columns=_config.field_size('table', 'instruments'),
compulsory=compulsory, name=name)
instruments_field = instruments_field.setResultsName('instruments')
return instruments_field
def standard_instrumentations(name=None, compulsory=False):
"""
Standard Instrumentations field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Standard Instrumentations field rules
"""
if name is None:
name = 'Standard Instrumentation Type'
standard_instrumentations_field = basic.lookup(_tables.standard_instrumentation_types(),
columns=_config.field_size('table', 'standard_instrumentations'),
compulsory=compulsory, name=name)
standard_instrumentations_field = standard_instrumentations_field.setResultsName('standard_instrumentation')
return standard_instrumentations_field
def writer_designation(name=None, compulsory=False):
"""
Writer Designation field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Writer Designation field rules
"""
if name is None:
name = 'Writer Designation'
writer_designation_field = basic.lookup(_tables.writer_designation_codes(),
columns=_config.field_size('table', 'writer_designation'),
compulsory=compulsory, name=name)
writer_designation_field = writer_designation_field.setResultsName('writer_designation')
return writer_designation_field
def ie_indicator(name=None, compulsory=False):
"""
Inclusion/Exclusion Indicator field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Inclusion/Exclusion Indicator field rules
"""
if name is None:
name = 'Inclusion/Exclusion Indicator'
ie_indicator_field = basic.lookup(_tables.ie_indicator(), compulsory=compulsory,
columns=_config.field_size('table', 'ie_indicator_field'),
name=name)
ie_indicator_field = ie_indicator_field.setResultsName('ie_indicator')
return ie_indicator_field
def agreement_type(name=None, compulsory=False):
"""
Agreement Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Agreement Type field rules
"""
if name is None:
name = 'Agreement Type'
agreement_type_field = basic.lookup(_tables.agreement_types(),
columns=_config.field_size('table', 'agreement_type'),
compulsory=compulsory, name=name)
agreement_type_field = agreement_type_field.setResultsName('agreement_type')
return agreement_type_field
def language_code(name=None, compulsory=False):
"""
Language Code field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Language Code field rules
"""
if name is None:
name = 'Language Code'
language_field = basic.lookup(_tables.language_codes(),
columns=_config.field_size('table', 'language_code'), compulsory=compulsory,
name=name)
language_field = language_field.setResultsName('language_code')
return language_field
def publisher_type(name=None, compulsory=False):
"""
Publisher Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Publisher Type field rules
"""
if name is None:
name = 'Publisher Type'
publisher_type_field = basic.lookup(_tables.publisher_types(),
columns=_config.field_size('table', 'publisher_type'), compulsory=compulsory,
name=name)
publisher_type_field = publisher_type_field.setResultsName('publisher_type')
return publisher_type_field
def subject_codes(name=None, compulsory=False):
"""
Subject Codes field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Subject Codes field rules
"""
if name is None:
name = 'Subject Code'
subject_codes_field = basic.lookup(_tables.subject_codes(),
columns=_config.field_size('table', 'subject_code'),
compulsory=compulsory, name=name)
subject_codes_field = subject_codes_field.setResultsName('subject_code')
return subject_codes_field
def title_type(name=None, compulsory=False):
"""
Title Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Title Type field rules
"""
if name is None:
name = 'Title Type'
title_type_field = basic.lookup(_tables.title_types(),
columns=_config.field_size('table', 'title_type'),
compulsory=compulsory, name=name)
title_type_field = title_type_field.setResultsName('title_type')
return title_type_field
def record_type(values):
"""
Creates a record type field.
These serve as the header field on records, identifying them.
Usually this field can be only an specific value, but sometimes a small
range of codes is allowed. This is specified by the 'values' parameter.
While it is possible to set this field as optional, it is expected to be
compulsory.
:param values: allowed record type codes
:return: grammar for the record type field
"""
field = basic.lookup(values, name='Record Type (one of %s)' % values)
return field.setResultsName('record_type')
def post_term_collection_status(name=None, compulsory=False):
"""
Post Term Collection Status field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Post Term Collection Status field rules
"""
if name is None:
name = 'Post Term Collection Status'
post_term_collection_status_field = basic.lookup(_tables.post_term_collection_status(),
columns=_config.field_size('table', 'post_term_collection_status'),
compulsory=compulsory, name=name)
post_term_collection_status_field = post_term_collection_status_field.setResultsName(
'post_term_collection_status')
return post_term_collection_status_field
def tis_code(name=None, compulsory=False):
"""
TIS Numeric Code field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the TIS Numeric Code field rules
"""
if name is None:
name = 'TIS Numeric Code'
tis_code_field = basic.lookup(_tables.tis_codes(),
columns=_config.field_size('table', 'tis_code'),
compulsory=compulsory, name=name)
tis_code_field = tis_code_field.setResultsName('tis_code')
tis_code_field.setParseAction(lambda c: int(c[0]))
return tis_code_field
def sm_clause(name=None, compulsory=False):
"""
Sales/Manufacture Clause field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Sales/Manufacture Clause field rules
"""
if name is None:
name = 'Sales/Manufacture Clause'
sm_clause_field = basic.lookup(_tables.sales_manufacture_clause(),
columns=_config.field_size('table', 'sm_clause'),
compulsory=compulsory,
name=name)
sm_clause_field = sm_clause_field.setResultsName('sales_manufacture_clause')
return sm_clause_field
def excerpt_type(name=None, compulsory=False):
"""
Excerpt Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Excerpt Type field rules
"""
if name is None:
name = 'Excerpt Type'
excerpt_type_field = basic.lookup(_tables.excerpt_types(),
columns=_config.field_size('table', 'excerpt_type'),
compulsory=compulsory,
name=name)
excerpt_type_field = excerpt_type_field.setResultsName('excerpt_type')
return excerpt_type_field
def version_type(name=None, compulsory=False):
"""
Version Type field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Version Type field rules
"""
if name is None:
name = 'Version Type'
version_type_field = basic.lookup(_tables.version_types(),
columns=_config.field_size('table', 'version_type'),
compulsory=compulsory,
name=name)
version_type_field = version_type_field.setResultsName('version_type')
return version_type_field
def music_arrangement(name=None, compulsory=False):
"""
Music Arrangement field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Music Arrangement field rules
"""
if name is None:
name = 'Music Arrangement'
music_arrangement_field = basic.lookup(_tables.music_arrangements(),
columns=_config.field_size('table', 'music_arrangement'),
compulsory=compulsory,
name=name)
music_arrangement_field = music_arrangement_field.setResultsName('music_arrangement')
return music_arrangement_field
def lyric_adaptation(name=None, compulsory=False):
"""
Lyric Adaptation field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Lyric Adaptation field rules
"""
if name is None:
name = 'Lyric Adaptation'
lyric_adaptation_field = basic.lookup(_tables.lyric_adaptations(),
columns=_config.field_size('table', 'lyric_adaptation'),
compulsory=compulsory,
name=name)
lyric_adaptation_field = lyric_adaptation_field.setResultsName('lyric_adaptation')
return lyric_adaptation_field
def usa_license(name=None, compulsory=False):
"""
USA License Indicator field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the USA License Indicator field rules
"""
if name is None:
name = 'USA License Indicator'
usa_license_field = basic.lookup(_tables.usa_license_indicators(),
columns=_config.field_size('table', 'usa_license'),
compulsory=compulsory,
name=name)
usa_license_field = usa_license_field.setResultsName('usa_license')
return usa_license_field
def prior_royalty_status(name=None, compulsory=False):
"""
Prior Royalty Status field.
:param name: name for the field
:param compulsory: indicates if the empty string is disallowed
:return: an instance of the Prior Royalty Status field rules
"""
if name is None:
name = 'Prior Royalty Status'
prior_royalty_status_field = basic.lookup(_tables.prior_royalty_status(),
columns=_config.field_size('table', 'prior_royalty_status'),
compulsory=compulsory, name=name)
prior_royalty_status_field = prior_royalty_status_field.setResultsName(
'prior_royalty_status')
return prior_royalty_status_field
def setUp(self):
self.lookup = basic.lookup(['AB1', 'CD2', 'EF3'])
def get_field(self, name=None, columns=None, values=None):
return basic.lookup(values, name)
