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_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_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 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)