Upload 53 files

examples/generate-data-english.py

@@ -0,0 +1,330 @@
+from geco_data_generator import (attrgenfunct, basefunctions, contdepfunct, generator, corruptor)
+import random
+random.seed(42)
+
+# Set the Unicode encoding for this data generation project. This needs to be
+# changed to another encoding for different Unicode character sets.
+# Valid encoding strings are listed here:
+# http://docs.python.org/library/codecs.html#standard-encodings
+#
+unicode_encoding_used = 'ascii'
+
+# The name of the record identifier attribute (unique value for each record).
+# This name cannot be given as name to any other attribute that is generated.
+#
+rec_id_attr_name = 'rec-id'
+
+# Set the file name of the data set to be generated (this will be a comma
+# separated values, CSV, file).
+#
+out_file_name = 'example-data-english.csv'
+
+# Set how many original and how many duplicate records are to be generated.
+#
+num_org_rec = 5_000_000
+num_dup_rec = 100_000
+
+# Set the maximum number of duplicate records can be generated per original
+# record.
+#
+max_duplicate_per_record = 3
+
+# Set the probability distribution used to create the duplicate records for one
+# original record (possible values are: 'uniform', 'poisson', 'zipf').
+#
+num_duplicates_distribution = 'zipf'
+
+# Set the maximum number of modification that can be applied to a single
+# attribute (field).
+#
+max_modification_per_attr = 1
+
+# Set the number of modification that are to be applied to a record.
+#
+num_modification_per_record = 5
+
+# Check if the given the unicode encoding selected is valid.
+#
+basefunctions.check_unicode_encoding_exists(unicode_encoding_used)
+
+# -----------------------------------------------------------------------------
+# Define the attributes to be generated (using methods from the generator.py
+# module).
+#
+gname_attr = generator.GenerateFreqAttribute(
+    attribute_name='given-name',
+    freq_file_name='givenname_f_freq.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+sname_attr = generator.GenerateFreqAttribute(
+    attribute_name='surname',
+    freq_file_name='surname-freq.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+postcode_attr = generator.GenerateFreqAttribute(
+    attribute_name='postcode',
+    freq_file_name='postcode_act_freq.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+phone_num_attr = generator.GenerateFuncAttribute(
+    attribute_name='telephone-number',
+    function=attrgenfunct.generate_phone_number_australia,
+)
+
+credit_card_attr = generator.GenerateFuncAttribute(
+    attribute_name='credit-card-number', function=attrgenfunct.generate_credit_card_number
+)
+
+age_uniform_attr = generator.GenerateFuncAttribute(
+    attribute_name='age-uniform',
+    function=attrgenfunct.generate_uniform_age,
+    parameters=[0, 120],
+)
+
+income_normal_attr = generator.GenerateFuncAttribute(
+    attribute_name='income-normal',
+    function=attrgenfunct.generate_normal_value,
+    parameters=[50000, 20000, 0, 1000000, 'float2'],
+)
+
+rating_normal_attr = generator.GenerateFuncAttribute(
+    attribute_name='rating-normal',
+    function=attrgenfunct.generate_normal_value,
+    parameters=[0.0, 1.0, None, None, 'float9'],
+)
+
+gender_city_comp_attr = generator.GenerateCateCateCompoundAttribute(
+    categorical1_attribute_name='gender',
+    categorical2_attribute_name='city',
+    lookup_file_name='gender-city.csv',
+    has_header_line=True,
+    unicode_encoding='ascii',
+)
+
+sex_income_comp_attr = generator.GenerateCateContCompoundAttribute(
+    categorical_attribute_name='sex',
+    continuous_attribute_name='income',
+    continuous_value_type='float1',
+    lookup_file_name='gender-income.csv',
+    has_header_line=False,
+    unicode_encoding='ascii',
+)
+
+gender_town_salary_comp_attr = generator.GenerateCateCateContCompoundAttribute(
+    categorical1_attribute_name='alternative-gender',
+    categorical2_attribute_name='town',
+    continuous_attribute_name='salary',
+    continuous_value_type='float4',
+    lookup_file_name='gender-city-income.csv',
+    has_header_line=False,
+    unicode_encoding='ascii',
+)
+
+age_blood_pressure_comp_attr = generator.GenerateContContCompoundAttribute(
+    continuous1_attribute_name='age',
+    continuous2_attribute_name='blood-pressure',
+    continuous1_funct_name='uniform',
+    continuous1_funct_param=[10, 110],
+    continuous2_function=contdepfunct.blood_pressure_depending_on_age,
+    continuous1_value_type='int',
+    continuous2_value_type='float3',
+)
+
+age_salary_comp_attr = generator.GenerateContContCompoundAttribute(
+    continuous1_attribute_name='age2',
+    continuous2_attribute_name='salary2',
+    continuous1_funct_name='normal',
+    continuous1_funct_param=[45, 20, 15, 130],
+    continuous2_function=contdepfunct.salary_depending_on_age,
+    continuous1_value_type='int',
+    continuous2_value_type='float1',
+)
+
+# -----------------------------------------------------------------------------
+# Define how the generated records are to be corrupted (using methods from
+# the corruptor.py module).
+
+# For a value edit corruptor, the sum or the four probabilities given must
+# be 1.0.
+#
+edit_corruptor = corruptor.CorruptValueEdit(
+    position_function=corruptor.position_mod_normal,
+    char_set_funct=basefunctions.char_set_ascii,
+    insert_prob=0.5,
+    delete_prob=0.5,
+    substitute_prob=0.0,
+    transpose_prob=0.0,
+)
+
+edit_corruptor2 = corruptor.CorruptValueEdit(
+    position_function=corruptor.position_mod_uniform,
+    char_set_funct=basefunctions.char_set_ascii,
+    insert_prob=0.25,
+    delete_prob=0.25,
+    substitute_prob=0.25,
+    transpose_prob=0.25,
+)
+
+surname_misspell_corruptor = corruptor.CorruptCategoricalValue(
+    lookup_file_name='surname-misspell.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+ocr_corruptor = corruptor.CorruptValueOCR(
+    position_function=corruptor.position_mod_normal,
+    lookup_file_name='ocr-variations.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+keyboard_corruptor = corruptor.CorruptValueKeyboard(
+    position_function=corruptor.position_mod_normal, row_prob=0.5, col_prob=0.5
+)
+
+phonetic_corruptor = corruptor.CorruptValuePhonetic(
+    lookup_file_name='phonetic-variations.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+missing_val_corruptor = corruptor.CorruptMissingValue()
+
+postcode_missing_val_corruptor = corruptor.CorruptMissingValue(missing_val='missing')
+
+given_name_missing_val_corruptor = corruptor.CorruptMissingValue(missing_value='unknown')
+
+# -----------------------------------------------------------------------------
+# Define the attributes to be generated for this data set, and the data set
+# itself.
+#
+attr_name_list = [
+    'gender',
+    'given-name',
+    'surname',
+    'postcode',
+    'city',
+    'telephone-number',
+    'credit-card-number',
+    'income-normal',
+    'age-uniform',
+    'income',
+    'age',
+    'sex',
+    'blood-pressure',
+]
+
+attr_data_list = [
+    gname_attr,
+    sname_attr,
+    postcode_attr,
+    phone_num_attr,
+    credit_card_attr,
+    age_uniform_attr,
+    income_normal_attr,
+    gender_city_comp_attr,
+    sex_income_comp_attr,
+    gender_town_salary_comp_attr,
+    age_blood_pressure_comp_attr,
+    age_salary_comp_attr,
+]
+
+# Nothing to change here - set-up the data set generation object.
+#
+test_data_generator = generator.GenerateDataSet(
+    output_file_name=out_file_name,
+    write_header_line=True,
+    rec_id_attr_name=rec_id_attr_name,
+    number_of_records=num_org_rec,
+    attribute_name_list=attr_name_list,
+    attribute_data_list=attr_data_list,
+    unicode_encoding=unicode_encoding_used,
+)
+
+# Define the probability distribution of how likely an attribute will be
+# selected for a modification.
+# Each of the given probability values must be between 0 and 1, and the sum of
+# them must be 1.0.
+# If a probability is set to 0 for a certain attribute, then no modification
+# will be applied on this attribute.
+#
+attr_mod_prob_dictionary = {
+    'gender': 0.1,
+    'given-name': 0.2,
+    'surname': 0.2,
+    'postcode': 0.1,
+    'city': 0.1,
+    'telephone-number': 0.15,
+    'credit-card-number': 0.1,
+    'age': 0.05,
+}
+
+# Define the actual corruption (modification) methods that will be applied on
+# the different attributes.
+# For each attribute, the sum of probabilities given must sum to 1.0.
+#
+attr_mod_data_dictionary = {
+    'gender': [(1.0, missing_val_corruptor)],
+    'surname': [
+        (0.1, surname_misspell_corruptor),
+        (0.1, ocr_corruptor),
+        (0.1, keyboard_corruptor),
+        (0.7, phonetic_corruptor),
+    ],
+    'given-name': [
+        (0.1, edit_corruptor2),
+        (0.1, ocr_corruptor),
+        (0.1, keyboard_corruptor),
+        (0.7, phonetic_corruptor),
+    ],
+    'postcode': [(0.8, keyboard_corruptor), (0.2, postcode_missing_val_corruptor)],
+    'city': [
+        (0.1, edit_corruptor),
+        (0.1, missing_val_corruptor),
+        (0.4, keyboard_corruptor),
+        (0.4, phonetic_corruptor),
+    ],
+    'age': [(1.0, edit_corruptor2)],
+    'telephone-number': [(1.0, missing_val_corruptor)],
+    'credit-card-number': [(1.0, edit_corruptor)],
+}
+
+# Nothing to change here - set-up the data set corruption object
+#
+test_data_corruptor = corruptor.CorruptDataSet(
+    number_of_org_records=num_org_rec,
+    number_of_mod_records=num_dup_rec,
+    attribute_name_list=attr_name_list,
+    max_num_dup_per_rec=max_duplicate_per_record,
+    num_dup_dist=num_duplicates_distribution,
+    max_num_mod_per_attr=max_modification_per_attr,
+    num_mod_per_rec=num_modification_per_record,
+    attr_mod_prob_dict=attr_mod_prob_dictionary,
+    attr_mod_data_dict=attr_mod_data_dictionary,
+)
+
+# =============================================================================
+# No need to change anything below here
+
+# Start the data generation process
+#
+rec_dict = test_data_generator.generate()
+
+assert len(rec_dict) == num_org_rec  # Check the number of generated records
+
+# Corrupt (modify) the original records into duplicate records
+#
+rec_dict = test_data_corruptor.corrupt_records(rec_dict)
+
+assert len(rec_dict) == num_org_rec + num_dup_rec  # Check total number of records
+
+# Write generate data into a file
+#
+test_data_generator.write()
+

examples/generate-data-japanese.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from geco_data_generator import basefunctions, attrgenfunct, contdepfunct, generator, corruptor
+import random
+random.seed(42)
+
+
+# Set the Unicode encoding for this data generation project. This needs to be
+# changed to another encoding for different Unicode character sets.
+# Valid encoding strings are listed here:
+# http://docs.python.org/library/codecs.html#standard-encodings
+#
+unicode_encoding_used = 'cp932'
+
+# The name of the record identifier attribute (unique value for each record).
+# This name cannot be given as name to any other attribute that is generated.
+#
+rec_id_attr_name = 'rec-id'
+
+# Set the file name of the data set to be generated (this will be a comma
+# separated values, CSV, file).
+#
+out_file_name = 'example-data-japanese.csv'
+
+# Set how many original and how many duplicate records are to be generated.
+#
+num_org_rec = 10000
+num_dup_rec = 10000
+
+# Set the maximum number of duplicate records can be generated per original
+# record.
+#
+max_duplicate_per_record = 3
+
+# Set the probability distribution used to create the duplicate records for one
+# original record (possible values are: 'uniform', 'poisson', 'zipf').
+#
+num_duplicates_distribution = 'zipf'
+
+# Set the maximum number of modification that can be applied to a single
+# attribute (field).
+#
+max_modification_per_attr = 1
+
+# Set the number of modification that are to be applied to a record.
+#
+num_modification_per_record = 5
+
+# Check if the given the unicode encoding selected is valid.
+#
+basefunctions.check_unicode_encoding_exists(unicode_encoding_used)
+
+# -----------------------------------------------------------------------------
+# Define the attributes to be generated (using methods from the generator.py
+# module).
+#
+surname_attr = generator.GenerateFreqAttribute(
+    attribute_name='surname',
+    freq_file_name='surname-freq-japanese.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+credit_card_attr = generator.GenerateFuncAttribute(
+    attribute_name='credit-card-number', function=attrgenfunct.generate_credit_card_number
+)
+
+age_normal_attr = generator.GenerateFuncAttribute(
+    attribute_name='age',
+    function=attrgenfunct.generate_normal_age,
+    parameters=[45, 30, 0, 130],
+)
+
+gender_city_comp_attr = generator.GenerateCateCateCompoundAttribute(
+    categorical1_attribute_name='gender',
+    categorical2_attribute_name='city',
+    lookup_file_name='gender-city-japanese.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+# -----------------------------------------------------------------------------
+# Define how the generated records are to be corrupted (using methods from
+# the corruptor.py module).
+
+# For a value edit corruptor, the sum or the four probabilities given must
+# be 1.0.
+#
+surname_misspell_corruptor = corruptor.CorruptCategoricalValue(
+    lookup_file_name='surname-misspell-japanese.csv',
+    has_header_line=False,
+    unicode_encoding=unicode_encoding_used,
+)
+
+edit_corruptor = corruptor.CorruptValueEdit(
+    position_function=corruptor.position_mod_normal,
+    char_set_funct=basefunctions.char_set_ascii,
+    insert_prob=0.0,
+    delete_prob=0.0,
+    substitute_prob=0.6,
+    transpose_prob=0.4,
+)
+
+missing_val_corruptor = corruptor.CorruptMissingValue()
+
+# -----------------------------------------------------------------------------
+# Define the attributes to be generated for this data set, and the data set
+# itself.
+#
+attr_name_list = ['surname', 'age', 'gender', 'city', 'credit-card-number']
+
+attr_data_list = [surname_attr, credit_card_attr, age_normal_attr, gender_city_comp_attr]
+
+# Nothing to change here - set-up the data set generation object.
+#
+test_data_generator = generator.GenerateDataSet(
+    output_file_name=out_file_name,
+    write_header_line=True,
+    rec_id_attr_name=rec_id_attr_name,
+    number_of_records=num_org_rec,
+    attribute_name_list=attr_name_list,
+    attribute_data_list=attr_data_list,
+    unicode_encoding=unicode_encoding_used,
+)
+
+# Define the probability distribution of how likely an attribute will be
+# selected for a modification.
+# Each of the given probability values must be between 0 and 1, and the sum of
+# them must be 1.0.
+# If a probability is set to 0 for a certain attribute, then no modification
+# will be applied on this attribute.
+#
+attr_mod_prob_dictionary = {
+    'surname': 0.5,
+    'age': 0.2,
+    'gender': 0.05,
+    'city': 0.05,
+    'credit-card-number': 0.2,
+}
+
+# Define the actual corruption (modification) methods that will be applied on
+# the different attributes.
+# For each attribute, the sum of probabilities given must sum to 1.0.
+#
+attr_mod_data_dictionary = {
+    'surname': [(0.9, surname_misspell_corruptor), (0.1, missing_val_corruptor)],
+    'age': [(0.1, missing_val_corruptor), (0.9, edit_corruptor)],
+    'gender': [(1.0, missing_val_corruptor)],
+    'city': [(1.0, missing_val_corruptor)],
+    'credit-card-number': [(0.1, missing_val_corruptor), (0.9, edit_corruptor)],
+}
+
+# Nothing to change here - set-up the data set corruption object
+#
+test_data_corruptor = corruptor.CorruptDataSet(
+    number_of_org_records=num_org_rec,
+    number_of_mod_records=num_dup_rec,
+    attribute_name_list=attr_name_list,
+    max_num_dup_per_rec=max_duplicate_per_record,
+    num_dup_dist=num_duplicates_distribution,
+    max_num_mod_per_attr=max_modification_per_attr,
+    num_mod_per_rec=num_modification_per_record,
+    attr_mod_prob_dict=attr_mod_prob_dictionary,
+    attr_mod_data_dict=attr_mod_data_dictionary,
+)
+
+# =============================================================================
+# No need to change anything below here
+
+# Start the generation process
+#
+rec_dict = test_data_generator.generate()
+
+assert len(rec_dict) == num_org_rec  # Check the number of generated records
+
+# Corrupt (modify) the original records into duplicate records
+#
+rec_dict = test_data_corruptor.corrupt_records(rec_dict)
+
+assert len(rec_dict) == num_org_rec + num_dup_rec  # Check total number of records
+
+# Write generate data into a file
+#
+test_data_generator.write()
+

geco_data_generator/__init__.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-

geco_data_generator/attrgenfunct.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Functions to generate independent attribute values
+import random
+
+from geco_data_generator import basefunctions
+
+
+
+
+def generate_phone_number_australia():
+    """
+    Randomly generate an Australian telephone number made of a two-digit area
+     code and an eight-digit number made of two blocks of four digits (with a
+     space between). For example: `02 1234 5678'
+
+     For details see: http://en.wikipedia.org/wiki/ \
+                      Telephone_numbers_in_Australia#Personal_numbers_.2805.29
+                      """
+
+    area_code = random.choice(['02', '03', '04', '07', '08'])
+
+    number1 = random.randint(1, 9999)
+    number2 = random.randint(1, 9999)
+
+    oz_phone_str = (
+        str(area_code) + ' ' + str(number1).zfill(4) + ' ' + str(number2).zfill(4)
+    )
+    assert len(oz_phone_str) == 12
+    assert oz_phone_str[0] == '0'
+
+    return oz_phone_str
+
+
+def generate_credit_card_number():
+    """Randomly generate a credit card made of four four-digit numbers (with a
+    space between each number group). For example: '1234 5678 9012 3456'
+
+    For details see: http://en.wikipedia.org/wiki/Bank_card_number
+    """
+
+    number1 = random.randint(1, 9999)
+    assert number1 > 0
+
+    number2 = random.randint(1, 9999)
+    assert number2 > 0
+
+    number3 = random.randint(1, 9999)
+    assert number3 > 0
+
+    number4 = random.randint(1, 9999)
+    assert number4 > 0
+
+    cc_str = (
+        str(number1).zfill(4)
+        + ' '
+        + str(number2).zfill(4)
+        + ' '
+        + str(number3).zfill(4)
+        + ' '
+        + str(number4).zfill(4)
+    )
+
+    assert len(cc_str) == 19
+
+    return cc_str
+
+
+#
+def generate_uniform_value(min_val, max_val, val_type):
+    """Randomly generate a numerical value according to a uniform distribution
+    between the minimum and maximum values given.
+
+    The value type can be set as 'int', so a string formatted as an integer
+    value is returned; or as 'float1' to 'float9', in which case a string
+    formatted as floating-point value with the specified number of digits
+    behind the comma is returned.
+
+    Note that for certain situations and string formats a value outside the
+    set range might be returned. For example, if min_val=100.25 and
+    val_type='float1' the rounding can result in a string value '100.2' to
+    be returned.
+
+    Suitable minimum and maximum values need to be selected to prevent such a
+    situation.
+    """
+
+    basefunctions.check_is_number('min_val', min_val)
+    basefunctions.check_is_number('max_val', max_val)
+    assert min_val < max_val
+
+    r = random.uniform(min_val, max_val)
+
+    return basefunctions.float_to_str(r, val_type)
+
+
+#
+def generate_uniform_age(min_val, max_val):
+    """Randomly generate an age value (returned as integer) according to a
+    uniform distribution between the minimum and maximum values given.
+
+    This function is simple a shorthand for:
+
+      generate_uniform_value(min_val, max_val, 'int')
+    """
+
+    assert min_val >= 0
+    assert max_val <= 130
+
+    return generate_uniform_value(min_val, max_val, 'int')
+
+
+def generate_normal_value(mu, sigma, min_val, max_val, val_type):
+    """Randomly generate a numerical value according to a normal distribution
+    with the mean (mu) and standard deviation (sigma) given.
+
+    A minimum and maximum allowed value can given as additional parameters,
+    if set to None then no minimum and/or maximum limit is set.
+
+    The value type can be set as 'int', so a string formatted as an integer
+    value is returned; or as 'float1' to 'float9', in which case a string
+    formatted as floating-point value with the specified number of digits
+    behind the comma is returned.
+    """
+
+    basefunctions.check_is_number('mu', mu)
+    basefunctions.check_is_number('sigma', sigma)
+    assert sigma > 0.0
+
+    if min_val != None:
+        basefunctions.check_is_number('min_val', min_val)
+        assert min_val <= mu
+
+    if max_val != None:
+        basefunctions.check_is_number('max_val', max_val)
+        assert max_val >= mu
+
+    if (min_val != None) and (max_val != None):
+        assert min_val < max_val
+
+    if (min_val != None) or (max_val != None):
+        in_range = False  # For testing if the random value is with the range
+    else:
+        in_range = True
+
+    r = random.normalvariate(mu, sigma)
+
+    while in_range == False:
+        if (min_val == None) or ((min_val != None) and (r >= min_val)):
+            in_range = True
+
+        if (max_val != None) and (r > max_val):
+            in_range = False
+
+        if in_range == True:
+            r_str = basefunctions.float_to_str(r, val_type)
+            r_test = float(r_str)
+            if (min_val != None) and (r_test < min_val):
+                in_range = False
+            if (max_val != None) and (r_test > max_val):
+                in_range = False
+
+        if in_range == False:
+            r = random.normalvariate(mu, sigma)
+
+    if min_val != None:
+        assert r >= min_val
+    if max_val != None:
+        assert r <= max_val
+
+    return basefunctions.float_to_str(r, val_type)
+
+
+#
+def generate_normal_age(mu, sigma, min_val, max_val):
+    """Randomly generate an age value (returned as integer) according to a
+    normal distribution following the mean and standard deviation values
+    given, and limited to age values between (including) the minimum and
+    maximum values given.
+
+    This function is simple a shorthand for:
+
+      generate_normal_value(mu, sigma, min_val, max_val, 'int')
+    """
+
+    assert min_val >= 0
+    assert max_val <= 130
+
+    age = generate_normal_value(mu, sigma, min_val, max_val, 'int')
+
+    while (int(age) < min_val) or (int(age) > max_val):
+        age = generate_normal_value(mu, sigma, min_val, max_val, 'int')
+
+    return age
+
+
+# =============================================================================
+
+# If called from command line perform some examples: Generate values
+#
+if __name__ == '__main__':
+
+    num_test = 20
+
+    print('Generate %d Australian telephone numbers:' % (num_test))
+    for i in range(num_test):
+        print(' ', generate_phone_number_australia())
+    print()
+
+    print('Generate %d credit card numbers:' % (num_test))
+    for i in range(num_test):
+        print(' ', generate_credit_card_number())
+    print()
+
+    print(
+        'Generate %d uniformly distributed integer numbers between -100' % (num_test)
+        + ' and -5:'
+    )
+    for i in range(num_test):
+        print(
+            ' ',
+            generate_uniform_value(-100, -5, 'int'),
+        )
+    print()
+
+    print(
+        'Generate %d uniformly distributed floating-point numbers with ' % (num_test)
+        + '3 digits between -55 and 55:'
+    )
+    for i in range(num_test):
+        print(' ', generate_uniform_value(-55, 55, 'float3'))
+    print()
+
+    print(
+        'Generate %d uniformly distributed floating-point numbers with ' % (num_test)
+        + '7 digits between 147 and 9843:'
+    )
+    for i in range(num_test):
+        print(' ', generate_uniform_value(147, 9843, 'float7'))
+    print()
+
+    print('Generate %d uniformly distributed age values between 0 and 120:' % (num_test))
+    for i in range(num_test):
+        print(' ', generate_uniform_age(0, 120))
+    print()
+
+    print('Generate %d uniformly distributed age values between 18 and 65:' % (num_test))
+    for i in range(num_test):
+        print(' ', generate_uniform_age(18, 65))
+    print()
+
+    print(
+        'Generate %d normally distributed integer numbers between -200' % (num_test)
+        + ' and -3 with mean -50 and standard deviation 44:'
+    )
+    for i in range(num_test):
+        print(' ', generate_normal_value(-50, 44, -200, -3, 'int'))
+    print()
+
+    print(
+        'Generate %d normally distributed floating-point numbers with ' % (num_test)
+        + '5 digits between -100 and 100 and with mean 22 and '
+        + 'standard deviation 74:'
+    )
+    for i in range(num_test):
+        print(' ', generate_normal_value(22, 74, -100, 100, 'float5'))
+    print()
+
+    print(
+        'Generate %d normally distributed floating-point numbers with ' % (num_test)
+        + '9 digits with mean 22 and standard deviation 74:'
+    )
+    for i in range(num_test):
+        print(
+            ' ',
+            generate_normal_value(22, 74, min_val=None, max_val=None, val_type='float9'),
+        )
+    print()
+
+    print(
+        'Generate %d normally distributed floating-point numbers with ' % (num_test)
+        + '2 digits with mean 22 and standard deviation 24 that'
+        + ' are larger than 10:'
+    )
+    for i in range(num_test):
+        print(
+            ' ', generate_normal_value(22, 74, min_val=10, max_val=None, val_type='float2')
+        )
+    print()
+
+    print(
+        'Generate %d normally distributed floating-point numbers with ' % (num_test)
+        + '4 digits with mean 22 and standard deviation 24 that'
+        + ' are smaller than 30:'
+    )
+    for i in range(num_test):
+        print(
+            ' ', generate_normal_value(22, 74, min_val=None, max_val=40, val_type='float4')
+        )
+    print()
+
+    print(
+        'Generate %d normally distributed age values between 0 and 120' % (num_test)
+        + ' with mean 45 and standard deviation 22:'
+    )
+    for i in range(num_test):
+        print(' ', generate_normal_age(45, 22, 0, 120))
+    print()
+
+    print(
+        'Generate %d normally distributed age values between 18 and 65' % (num_test)
+        + ' with mean 30 and standard deviation 10:'
+    )
+    for i in range(num_test):
+        print(' ', generate_normal_age(30, 10, 18, 65))
+    print()

geco_data_generator/basefunctions.py

@@ -0,0 +1,614 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Helper functions
+import codecs  # Used to read and write Unicode files
+import os
+import types
+
+HERE = os.path.abspath(os.path.dirname(__file__))
+DATA = os.path.join(HERE, 'data')
+
+def check_is_not_none(variable, value):
+    """Check if the value given is not None.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if value == None:
+        raise Exception('Value of "%s" is None' % (variable))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_string(variable, value):
+    """Check if the value given is of type string.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, str):
+        raise Exception(
+            'Value of "%s" is not a string: %s (%s)' % (variable, str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_unicode_string(variable, value):
+    """Check if the value given is of type unicode string.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_string_or_unicode_string(variable, value):
+    """Check if the value given is of type string or unicode string.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, str):
+        raise Exception(
+            'Value of "%s" is neither a string nor a Unicode ' % (variable)
+            + 'string: %s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_non_empty_string(variable, value):
+    """Check if the value given is of type string and is not an empty string.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    if (not isinstance(variable, str)) or (variable == ''):
+        raise Exception(
+            'Value of "variable" is not a non-empty string: %s (%s)'
+            % (str(variable), type(variable))
+        )
+
+    if (not isinstance(value, str)) or (value == ''):
+        raise Exception(
+            'Value of "%s" is not a non-empty string: %s (%s)'
+            % (variable, str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_number(variable, value):
+    """Check if the value given is a number, i.e. of type integer or float.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if (not isinstance(value, int)) and (not isinstance(value, float)):
+        raise Exception(
+            'Value of "%s" is not a number: %s (%s)' % (variable, str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_positive(variable, value):
+    """Check if the value given is a positive number, i.e. of type integer or
+    float, and larger than zero.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if (not isinstance(value, int)) and (not isinstance(value, float)) or (value <= 0.0):
+        raise Exception(
+            'Value of "%s" is not a positive number: ' % (variable)
+            + '%s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_not_negative(variable, value):
+    """Check if the value given is a non-negative number, i.e. of type integer or
+    float, and larger than or equal to zero.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if (not isinstance(value, int)) and (not isinstance(value, float)) or (value < 0.0):
+        raise Exception(
+            'Value of "%s" is not a number or it is a ' % (variable)
+            + 'negative number: %s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_normalised(variable, value):
+    """Check if the value given is a number, i.e. of type integer or float, and
+    between (including) 0.0 and 1.0.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if (
+        (not isinstance(value, int))
+        and (not isinstance(value, float))
+        or (value < 0.0)
+        or (value > 1.0)
+    ):
+        raise Exception(
+            'Value of "%s" is not a normalised number ' % (variable)
+            + '(between 0.0 and 1.0): %s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_percentage(variable, value):
+    """Check if the value given is a number, i.e. of type integer or float, and
+    between (including) 0 and 100.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if (
+        (not isinstance(value, int))
+        and (not isinstance(value, float))
+        or (value < 0.0)
+        or (value > 100.0)
+    ):
+        raise Exception(
+            'Value of "%s" is not a percentage number ' % (variable)
+            + '(between 0.0 and 100.0): %s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_integer(variable, value):
+    """Check if the value given is an integer number.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, int):
+        raise Exception(
+            'Value of "%s" is not an integer: %s (%s)'
+            % (variable, str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_float(variable, value):
+    """Check if the value given is a floating-point number.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, float):
+        raise Exception(
+            'Value of "%s" is not a floating point ' % (variable)
+            + 'number: %s (%s)' % (str(value), type(value))
+        )
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_dictionary(variable, value):
+    """Check if the value given is of type dictionary.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, dict):
+        raise Exception('Value of "%s" is not a dictionary: %s' % (variable, type(value)))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_list(variable, value):
+    """Check if the value given is of type dictionary.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, list):
+        raise Exception('Value of "%s" is not a list: %s' % (variable, type(value)))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_set(variable, value):
+    """Check if the value given is of type set.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, set):
+        raise Exception('Value of "%s" is not a set: %s' % (variable, type(value)))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_tuple(variable, value):
+    """Check if the value given is of type tuple.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if not isinstance(value, tuple):
+        raise Exception('Value of "%s" is not a tuple: %s' % (variable, type(value)))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_flag(variable, value):
+    """Check if the value given is either True or False.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if value not in [True, False]:
+        raise Exception('Value of "%s" is not True or False: %s' % (variable, str(value)))
+
+
+# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+def check_is_function_or_method(variable, value):
+    """Check if the value given is a function or method.
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if type(value) not in [types.FunctionType, types.MethodType]:
+        raise Exception(
+            '%s is not a function or method: %s' % (str(variable), type(value))
+        )
+
+
+def check_unicode_encoding_exists(unicode_encoding_str):
+    """A function which checks if the given Unicode encoding string is known to
+    the Python codec registry.
+
+    If the string is unknown this functions ends with an exception.
+    """
+
+    check_is_string_or_unicode_string('unicode_encoding_str', unicode_encoding_str)
+
+    try:
+        codecs.lookup(unicode_encoding_str)
+    except:
+        raise Exception('Unknown Unicode encoding string: "%s"' % (unicode_encoding_str))
+
+
+def char_set_ascii(s):
+    """Determine if the input string contains digits, letters, or both, as well
+    as whitespaces or not.
+
+    Returns a string containing the set of corresponding characters.
+    """
+
+    check_is_string_or_unicode_string('s', s)
+
+    if len(s) == 0:
+        return ''
+
+    if ' ' in s:
+        includes_spaces = True
+    else:
+        includes_spaces = False
+
+    # Remove whitespaces
+    #
+    check_str = s.replace(' ', '')
+
+    # Check if string contains characters other than alpha-numeric characters
+    #
+    if check_str.isalnum() == False:
+        return ''
+
+        # Return an empty string rather than stopping program
+        #
+        # raise Exception, 'The string "%s" contains characters other than ' % \
+        #                 (check_str) + 'alpha numeric and whitespace'
+
+    # Check if string contains letters only, digits only, or both
+    #
+    if check_str.isdigit() == True:
+        char_set = '0123456789'
+    elif check_str.isalpha() == True:
+        char_set = 'abcdefghijklmnopqrstuvwxyz'
+    else:
+        char_set = 'abcdefghijklmnopqrstuvwxyz0123456789'
+
+    if includes_spaces == True:
+        char_set += ' '
+
+    return char_set
+
+
+def check_is_valid_format_str(variable, value):
+    """Check if the value given is a valid formatting string for numbers.
+    Possible formatting values are:
+
+    int, float1, float2, float3, float4, float5, float6, float7, float8, or
+    float9
+
+    The argument 'variable' needs to be set to the name (as a string) of the
+    value which is checked.
+    """
+
+    check_is_non_empty_string('variable', variable)
+
+    if value not in [
+        'int',
+        'float1',
+        'float2',
+        'float3',
+        'float4',
+        'float5',
+        'float6',
+        'float7',
+        'float8',
+        'float9',
+    ]:
+        raise Exception(
+            '%s is not a validformat string: %s' % (str(variable), type(value))
+        )
+
+
+def float_to_str(f, format_str):
+    """Convert the given floating-point (or integer) number into a string
+    according to the format string given.
+
+    The format string can be one of 'int' (return a string that corresponds to
+    an integer value), or 'float1', 'float2', ..., 'float9' which returns a
+    string of the number with the specified number of digits behind the comma.
+    """
+
+    check_is_number('f', f)
+
+    check_is_string('format_str', format_str)
+    check_is_valid_format_str('format_str', format_str)
+
+    if format_str == 'int':
+        f_str = '%.0f' % (f)
+    elif format_str == 'float1':
+        f_str = '%.1f' % (f)
+    elif format_str == 'float2':
+        f_str = '%.2f' % (f)
+    elif format_str == 'float3':
+        f_str = '%.3f' % (f)
+    elif format_str == 'float4':
+        f_str = '%.4f' % (f)
+    elif format_str == 'float5':
+        f_str = '%.5f' % (f)
+    elif format_str == 'float6':
+        f_str = '%.6f' % (f)
+    elif format_str == 'float7':
+        f_str = '%.7f' % (f)
+    elif format_str == 'float8':
+        f_str = '%.8f' % (f)
+    elif format_str == 'float9':
+        f_str = '%.9f' % (f)
+    else:
+        raise Exception('Illegal string format given: "%s"' % (format_str))
+
+    return f_str
+
+
+def str2comma_separated_list(s):
+    """A function which splits the values in a list at commas, and checks all
+    values if they are quoted (double or single) at both ends or not. Quotes
+    are removed.
+
+    Note that this function will split values that are quoted but contain one
+    or more commas into several values.
+    """
+
+    check_is_unicode_string('s', s)
+
+    in_list = s.split(',')
+    out_list = []
+
+    for e in in_list:
+        e = e.strip()
+        if (e.startswith('"') and e.endswith('"')) or (
+            e.startswith("'") and e.endswith("'")
+        ):
+            e = e[1:-1]  # Remove quotes
+        out_list.append(e)
+
+    return out_list
+
+
+def read_csv_file(file_name, encoding, header_line):
+    """Read a comma separated values (CSV) file from disk using the given Unicode
+    encoding.
+
+    Arguments:
+    file_name    Name of the file to read.
+
+    encoding     The name of a Unicode encoding to be used when reading the
+                 file.
+                 If set to None then the standard 'ascii' encoding will be
+                 used.
+
+    header_line  A flag, set to True or False, that has to be set according
+                 to if the frequency file starts with a header line or not.
+
+    This function returns two items:
+    - If given, a list that contains the values in the header line of the
+      file. If no header line was given, this item will be set to None.
+
+    - A list containing the records in the CSV file, each as a list.
+
+    Notes:
+    - Lines starting with # are assumed to contain comments and will be
+      skipped. Lines that are empty will also be skipped.
+    - The CSV files must not contain commas in the values, while values
+      in quotes (double or single) can be handled.
+    """
+
+    check_is_string('file_name', file_name)
+    check_is_flag('header_line', header_line)
+
+    # if encoding == None:  # Use default ASCII encoding
+    #     encoding = 'ascii'
+    # check_is_string('encoding', encoding)
+    # check_unicode_encoding_exists(encoding)
+    if not os.path.exists(file_name):
+        file_name = os.path.join(DATA, file_name)
+    try:
+        in_file = open(os.path.join(DATA, file_name), encoding="utf-8")
+    except:
+        raise IOError('Cannot read CSV file "%s"' % (file_name))
+
+    if header_line == True:
+        header_line = in_file.readline()
+        # print 'Header line:', header_line
+
+        header_list = str2comma_separated_list(header_line)
+
+    else:
+        # print 'No header line'
+        header_list = None
+
+    file_data = []
+
+    for line_str in in_file:
+        line_str = line_str.strip()
+        if (line_str.startswith('#') == False) and (line_str != ''):
+            line_list = str2comma_separated_list(line_str)
+
+            file_data.append(line_list)
+
+    in_file.close()
+
+    return header_list, file_data
+
+
+def write_csv_file(file_name, encoding, header_list, file_data):
+    """Write a comma separated values (CSV) file to disk using the given Unicode
+    encoding.
+
+    Arguments:
+    file_name    Name of the file to write.
+
+    encoding     The name of a Unicode encoding to be used when reading the
+                 file.
+                 If set to None then the standard 'ascii' encoding will be
+                 used.
+
+    header_list  A list containing the attribute (field) names to be written
+                 at the beginning of the file.
+                 If no header line is to be written then this argument needs
+                 to be set to None.
+
+    file_data    A list containing the records to be written into the CSV
+                 file. Each record must be a list of values, and these values
+                 will be concatenated with commas and written into the file.
+                 It is assumed the values given do not contain comas.
+    """
+
+    check_is_string('file_name', file_name)
+    check_is_list('file_data', file_data)
+
+    if encoding == None:  # Use default ASCII encoding
+        encoding = 'ascii'
+    check_is_string('encoding', encoding)
+    check_unicode_encoding_exists(encoding)
+
+    try:
+        out_file = codecs.open(file_name, 'w', encoding=encoding)
+    except:
+        raise IOError('Cannot write CSV file "%s"' % (file_name))
+
+    if header_list != None:
+        check_is_list('header_list', header_list)
+        header_str = ','.join(header_list)
+        # print 'Header line:', header_str
+        out_file.write(header_str + os.linesep)
+
+    i = 0
+    for rec_list in file_data:
+        check_is_list('rec_list %d' % (i), rec_list)
+
+        line_str = ','.join(rec_list)
+        out_file.write(line_str + os.linesep)
+
+        i += 1
+
+    out_file.close()

geco_data_generator/contdepfunct.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Functions to generate dependent continuous attribute
+import random
+
+
+def blood_pressure_depending_on_age(age):
+    """Randomly generate a blood pressure value depending upon the given age
+    value.
+
+    It is assumed that for a given age value the blood pressure is normally
+    distributed with an average blood pressure of 75 at birth (age 0) and of
+    90 at age 100, and standard deviation in blood pressure of 4.
+    """
+
+    if (not isinstance(age, int)) and (not isinstance(age, float)):
+        raise Exception('Age value given is not a number: %s' % (str(age)))
+
+    if (age < 0) or (age > 130):
+        raise Exception('Age value below 0 or above 130 given')
+
+    avrg_bp = 75.0 + age / 100.0
+
+    std_dev_bp = 4.0
+
+    bp = random.normalvariate(avrg_bp, std_dev_bp)
+
+    if bp < 0.0:
+        bp = 0.0
+        print('Warning, blood pressure value of 0.0 returned!')
+
+    return bp
+
+
+# -----------------------------------------------------------------------------
+
+
+def salary_depending_on_age(age):
+    """Randomly generate a salary value depending upon the given age value.
+
+    It is assumed that for a given age value the salary is uniformly
+    distributed with an average salary of between 20,000 at age 18 (salary
+    will be set to 0 if an age is below 18) and 80,000 at age 60.
+
+    The minimum salary will stay at 10,000 while the maximum salary will
+    increase from 30,000 at age 18 to 150,000 at age 60.
+    """
+
+    if (not isinstance(age, int)) and (not isinstance(age, float)):
+        raise Exception('Age value given is not a number: %s' % (str(age)))
+
+    if (age < 0) or (age > 130):
+        raise Exception('Age value below 0 or above 130 given')
+
+    if age < 18.0:
+        sal = 0.0
+
+    else:
+        min_sal = 10000.0
+        max_sal = 10000.0 + (age - 18.0) * (140000.0 / 42)
+
+        sal = random.uniform(min_sal, max_sal)
+
+    return sal

geco_data_generator/corruptor.py

@@ -0,0 +1,2035 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Main classes to corrupt attribute values and records
+import math
+import random
+
+from geco_data_generator import basefunctions
+
+
+# =============================================================================
+# Helper functions to randomly select a position for where to apply a
+# modification
+
+
+def position_mod_uniform(in_str):
+    """Select any position in the given input string with uniform likelihood.
+
+    Return 0 is the string is empty.
+    """
+
+    if in_str == '':  # Empty input string
+        return 0
+
+    max_pos = len(in_str) - 1
+
+    pos = random.randint(0, max_pos)  # String positions start at 0
+
+    return pos
+
+
+# -----------------------------------------------------------------------------
+
+
+def position_mod_normal(in_str):
+    """Select any position in the given input string with normally distributed
+    likelihood where the average of the normal distribution is set to one
+    character behind the middle of the string, and the standard deviation is
+    set to 1/4 of the string length.
+
+    This is based on studies on the distribution of errors in real text which
+    showed that errors such as typographical mistakes are more likely to
+    appear towards the middle and end of a string but not at the beginning.
+
+    Return 0 is the string is empty.
+    """
+
+    if in_str == '':  # Empty input string
+        return 0
+
+    str_len = len(in_str)
+
+    mid_pos = str_len / 2.0 + 1
+    std_dev = str_len / 4.0
+    max_pos = str_len - 1
+
+    pos = int(round(random.gauss(mid_pos, std_dev)))
+    while (pos < 0) or (pos > max_pos):
+        pos = int(round(random.gauss(mid_pos, std_dev)))
+
+    return pos
+
+
+# =============================================================================
+# Classes for corrupting a value in a single attribute (field) of the data set
+# =============================================================================
+
+
+class CorruptValue:
+    """Base class for the definition of corruptor that is applied on a single
+    attribute (field) in the data set.
+
+    This class and all of its derived classes provide methods that allow the
+    definition of how values in a single attribute are corrupted (modified)
+    and the parameters necessary for the corruption process.
+
+    The following variables need to be set when a CorruptValue instance is
+    initialised (with further parameters listed in the derived classes):
+
+    position_function  A function that (somehow) determines the location
+                       within a string value of where a modification
+                       (corruption) is to be applied. The input of this
+                       function is assumed to be a string and its return value
+                       an integer number in the range of the length of the
+                       given input string.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, base_kwargs):
+        """Constructor, set general attributes."""
+
+        # General attributes for all attribute corruptors.
+        #
+        self.position_function = None
+
+        # Process the keyword argument (all keywords specific to a certain data
+        # generator type were processed in the derived class constructor)
+        #
+        for (keyword, value) in base_kwargs.items():
+
+            if keyword.startswith('position'):
+                basefunctions.check_is_function_or_method('position_function', value)
+                self.position_function = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        basefunctions.check_is_function_or_method(
+            'position_function', self.position_function
+        )
+
+        # Check if the position function does return an integer value
+        #
+        pos = self.position_function('test')
+        if (not isinstance(pos, int)) or (pos < 0) or (pos > 3):
+            raise Exception(
+                'Position function returns an illegal value (either'
+                + 'not an integer or and integer out of range: %s' % (str(pos))
+            )
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, str):
+        """Method which corrupts the given input string and returns the modified
+        string.
+        See implementations in derived classes for details.
+        """
+
+        raise Exception('Override abstract method in derived class')
+
+
+# =============================================================================
+
+
+class CorruptMissingValue(CorruptValue):
+    """A corruptor method which simply sets an attribute value to a missing
+    value.
+
+    The additional argument (besides the base class argument
+    'position_function') that has to be set when this attribute type is
+    initialised are:
+
+    missing_val  The string which designates a missing value. Default value
+                 is the empty string ''.
+
+    Note that the 'position_function' is not required by this corruptor
+    method.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.missing_val = ''
+        self.name = 'Missing value'
+
+        def dummy_position(s):  # Define a dummy position function
+            return 0
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('miss'):
+                basefunctions.check_is_string('missing_val', value)
+                self.missing_val = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        base_kwargs['position_function'] = dummy_position
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Simply return the missing value string."""
+
+        return self.missing_val
+
+
+# =============================================================================
+
+
+class CorruptValueEdit(CorruptValue):
+    """A simple corruptor which applies one edit operation on the given value.
+
+    Depending upon the content of the value (letters, digits or mixed), if the
+    edit operation is an insert or substitution a character from the same set
+    (letters, digits or both) is selected.
+
+    The additional arguments (besides the base class argument
+    'position_function') that has to be set when this attribute type is
+    initialised are:
+
+    char_set_funct   A function which determines the set of characters that
+                     can be inserted or used of substitution
+    insert_prob      These for values set the likelihood of which edit
+    delete_prob      operation will be selected.
+    substitute_prob  All four probability values must be between 0 and 1, and
+    transpose_prob   the sum of these four values must be 1.0
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.char_set_funct = None
+        self.insert_prob = None
+        self.delete_prob = None
+        self.substitute_prob = None
+        self.transpose_prob = None
+        self.name = 'Edit operation'
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('char'):
+                basefunctions.check_is_function_or_method('char_set_funct', value)
+                self.char_set_funct = value
+
+            elif keyword.startswith('ins'):
+                basefunctions.check_is_normalised('insert_prob', value)
+                self.insert_prob = value
+
+            elif keyword.startswith('del'):
+                basefunctions.check_is_normalised('delete_prob', value)
+                self.delete_prob = value
+
+            elif keyword.startswith('sub'):
+                basefunctions.check_is_normalised('substitute_prob', value)
+                self.substitute_prob = value
+
+            elif keyword.startswith('tran'):
+                basefunctions.check_is_normalised('transpose_prob', value)
+                self.transpose_prob = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_function_or_method('char_set_funct', self.char_set_funct)
+        basefunctions.check_is_normalised('insert_prob', self.insert_prob)
+        basefunctions.check_is_normalised('delete_prob', self.delete_prob)
+        basefunctions.check_is_normalised('substitute_prob', self.substitute_prob)
+        basefunctions.check_is_normalised('transpose_prob', self.transpose_prob)
+
+        # Check if the character set function returns a string
+        #
+        test_str = self.char_set_funct('test')  # This might become a problem
+        basefunctions.check_is_string_or_unicode_string('test_str', test_str)
+
+        if (
+            abs(
+                (
+                    self.insert_prob
+                    + self.delete_prob
+                    + self.substitute_prob
+                    + self.transpose_prob
+                )
+                - 1.0
+            )
+            > 0.0000001
+        ):
+            raise Exception('The four edit probabilities do not sum to 1.0')
+
+        # Calculate the probability ranges for the four edit operations
+        #
+        self.insert_range = [0.0, self.insert_prob]
+        self.delete_range = [self.insert_range[1], self.insert_range[1] + self.delete_prob]
+        self.substitute_range = [
+            self.delete_range[1],
+            self.delete_range[1] + self.substitute_prob,
+        ]
+        self.transpose_range = [
+            self.substitute_range[1],
+            self.substitute_range[1] + self.transpose_prob,
+        ]
+        assert self.transpose_range[1] == 1.0
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Method which corrupts the given input string and returns the modified
+        string by randomly selecting an edit operation and position in the
+        string where to apply this edit.
+        """
+
+        if len(in_str) == 0:  # Empty string, no modification possible
+            return in_str
+
+        # Randomly select an edit operation
+        #
+        r = random.random()
+
+        if r < self.insert_range[1]:
+            edit_op = 'ins'
+        elif (r >= self.delete_range[0]) and (r < self.delete_range[1]):
+            edit_op = 'del'
+        elif (r >= self.substitute_range[0]) and (r < self.substitute_range[1]):
+            edit_op = 'sub'
+        else:
+            edit_op = 'tra'
+
+        # Do some checks if only a valid edit operations was selected
+        #
+        if edit_op == 'ins':
+            assert self.insert_prob > 0.0
+        elif edit_op == 'del':
+            assert self.delete_prob > 0.0
+        elif edit_op == 'sub':
+            assert self.substitute_prob > 0.0
+        else:
+            assert self.transpose_prob > 0.0
+
+        # If the input string is empty only insert is possible
+        #
+        if (len(in_str) == 0) and (edit_op != 'ins'):
+            return in_str  # Return input string without modification
+
+        # If the input string only has one character then transposition is not
+        # possible
+        #
+        if (len(in_str) == 1) and (edit_op == 'tra'):
+            return in_str  # Return input string without modification
+
+        # Position in string where to apply the modification
+        #
+        # For a transposition we cannot select the last position in the string
+        # while for an insert we can specify the position after the last
+        if edit_op == 'tra':
+            len_in_str = in_str[:-1]
+        elif edit_op == 'ins':
+            len_in_str = in_str + 'x'
+        else:
+            len_in_str = in_str
+        mod_pos = self.position_function(len_in_str)
+
+        # Get the set of possible characters that can be inserted or substituted
+        #
+        char_set = self.char_set_funct(in_str)
+
+        if char_set == '':  # No possible value change
+            return in_str
+
+        if edit_op == 'ins':  # Insert a character
+            ins_char = random.choice(char_set)
+            new_str = in_str[:mod_pos] + ins_char + in_str[mod_pos:]
+
+        elif edit_op == 'del':  # Delete a character
+            new_str = in_str[:mod_pos] + in_str[mod_pos + 1 :]
+
+        elif edit_op == 'sub':  # Substitute a character
+            sub_char = random.choice(char_set)
+            new_str = in_str[:mod_pos] + sub_char + in_str[mod_pos + 1 :]
+
+        else:  # Transpose two characters
+            char1 = in_str[mod_pos]
+            char2 = in_str[mod_pos + 1]
+            new_str = in_str[:mod_pos] + char2 + char1 + in_str[mod_pos + 2 :]
+
+        return new_str
+
+
+# =============================================================================
+
+
+class CorruptValueKeyboard(CorruptValue):
+    """Use a keyboard layout to simulate typing errors. They keyboard is
+    hard-coded into this method, but can be changed easily for different
+    keyboard layout.
+
+    A character from the original input string will be randomly chosen using
+    the position function, and then a character from either the same row or
+    column in the keyboard will be selected.
+
+    The additional arguments (besides the base class argument
+    'position_function') that have to be set when this attribute type is
+    initialised are:
+
+    row_prob  The probability that a neighbouring character in the same row
+              is selected.
+
+    col_prob  The probability that a neighbouring character in the same
+              column is selected.
+
+    The sum of row_prob and col_prob must be 1.0.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.row_prob = None
+        self.col_prob = None
+        self.name = 'Keybord value'
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('row'):
+                basefunctions.check_is_normalised('row_prob', value)
+                self.row_prob = value
+
+            elif keyword.startswith('col'):
+                basefunctions.check_is_normalised('col_prob', value)
+                self.col_prob = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_normalised('row_prob', self.row_prob)
+        basefunctions.check_is_normalised('col_prob', self.col_prob)
+
+        if abs((self.row_prob + self.col_prob) - 1.0) > 0.0000001:
+            raise Exception('Sum of row and column probablities does not sum ' + 'to 1.0')
+
+        # Keyboard substitutions gives two dictionaries with the neigbouring keys
+        # for all leters both for rows and columns (based on ideas implemented by
+        # Mauricio A. Hernandez in his dbgen).
+        # This following data structures assume a QWERTY keyboard layout
+        #
+        self.rows = {
+            'a': 's',
+            'b': 'vn',
+            'c': 'xv',
+            'd': 'sf',
+            'e': 'wr',
+            'f': 'dg',
+            'g': 'fh',
+            'h': 'gj',
+            'i': 'uo',
+            'j': 'hk',
+            'k': 'jl',
+            'l': 'k',
+            'm': 'n',
+            'n': 'bm',
+            'o': 'ip',
+            'p': 'o',
+            'q': 'w',
+            'r': 'et',
+            's': 'ad',
+            't': 'ry',
+            'u': 'yi',
+            'v': 'cb',
+            'w': 'qe',
+            'x': 'zc',
+            'y': 'tu',
+            'z': 'x',
+            '1': '2',
+            '2': '13',
+            '3': '24',
+            '4': '35',
+            '5': '46',
+            '6': '57',
+            '7': '68',
+            '8': '79',
+            '9': '80',
+            '0': '9',
+        }
+
+        self.cols = {
+            'a': 'qzw',
+            'b': 'gh',
+            'c': 'df',
+            'd': 'erc',
+            'e': 'ds34',
+            'f': 'rvc',
+            'g': 'tbv',
+            'h': 'ybn',
+            'i': 'k89',
+            'j': 'umn',
+            'k': 'im',
+            'l': 'o',
+            'm': 'jk',
+            'n': 'hj',
+            'o': 'l90',
+            'p': '0',
+            'q': 'a12',
+            'r': 'f45',
+            's': 'wxz',
+            't': 'g56',
+            'u': 'j78',
+            'v': 'fg',
+            'w': 's23',
+            'x': 'sd',
+            'y': 'h67',
+            'z': 'as',
+            '1': 'q',
+            '2': 'qw',
+            '3': 'we',
+            '4': 'er',
+            '5': 'rt',
+            '6': 'ty',
+            '7': 'yu',
+            '8': 'ui',
+            '9': 'io',
+            '0': 'op',
+        }
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Method which corrupts the given input string by replacing a single
+        character with a neighbouring character given the defined keyboard
+        layout at a position randomly selected by the position function.
+        """
+
+        if len(in_str) == 0:  # Empty string, no modification possible
+            return in_str
+
+        max_try = 10  # Maximum number of tries to find a keyboard modification at
+        # a randomly selected position
+
+        done_key_mod = False  # A flag, set to true once a modification is done
+        try_num = 0
+
+        mod_str = in_str[:]  # Make a copy of the string which will be modified
+
+        while (done_key_mod == False) and (try_num < max_try):
+
+            mod_pos = self.position_function(mod_str)
+            mod_char = mod_str[mod_pos]
+
+            r = random.random()  # Create a random number between 0 and 1
+
+            if r <= self.row_prob:  # See if there is a row modification
+                if mod_char in self.rows:
+                    key_mod_chars = self.rows[mod_char]
+                    done_key_mod = True
+
+            else:  # See if there is a column modification
+                if mod_char in self.cols:
+                    key_mod_chars = self.cols[mod_char]
+                    done_key_mod = True
+
+            if done_key_mod == False:
+                try_num += 1
+
+        # If a modification is possible do it
+        #
+        if done_key_mod == True:
+
+            # Randomly select one of the possible characters
+            #
+            new_char = random.choice(key_mod_chars)
+
+            mod_str = mod_str[:mod_pos] + new_char + mod_str[mod_pos + 1 :]
+
+        assert len(mod_str) == len(in_str)
+
+        return mod_str
+
+
+# =============================================================================
+
+
+class CorruptValueOCR(CorruptValue):
+    """Simulate OCR errors using a list of similar pairs of characters or strings
+    that will be applied on the original string values.
+
+    These pairs of characters will be loaded from a look-up file which is a
+    CSV file with two columns, the first is a single character or character
+    sequence, and the second column is also a single character or character
+    sequence. It is assumed that the second value is an OCR modification of
+    the first value, and the other way round. For example:
+
+      5,S
+      5,s
+      2,Z
+      2,z
+      1,|
+      6,G
+
+    It is possible for an 'original' string value (first column) to have
+    several variations (second column). In such a case one variation will be
+    randomly selected during the value corruption (modification) process.
+
+    The additional arguments (besides the base class argument
+    'position_function') that have to be set when this attribute type is
+    initialised are:
+
+    lookup_file_name  Name of the file which contains the OCR character
+                      variations.
+
+    has_header_line   A flag, set to True or False, that has to be set
+                      according to if the look-up file starts with a header
+                      line or not.
+
+    unicode_encoding  The Unicode encoding (a string name) of the file.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.lookup_file_name = None
+        self.has_header_line = None
+        self.unicode_encoding = None
+        self.ocr_val_dict = {}  # The dictionary to hold the OCR variations
+        self.name = 'OCR value'
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        # Load the OCR variations lookup file - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        # Process values from file and their frequencies
+        #
+        for rec_list in lookup_file_data:
+            if len(rec_list) != 2:
+                raise Exception(
+                    'Illegal format in OCR variations lookup file '
+                    + '%s: %s' % (self.lookup_file_name, str(rec_list))
+                )
+            org_val = rec_list[0].strip()
+            var_val = rec_list[1].strip()
+
+            if org_val == '':
+                raise Exception(
+                    'Empty original OCR value in lookup file %s' % (self.lookup_file_name)
+                )
+            if var_val == '':
+                raise Exception(
+                    'Empty OCR variation value in lookup file %s' % (self.lookup_file_name)
+                )
+            if org_val == var_val:
+                raise Exception(
+                    'OCR variation is the same as original value in '
+                    + 'lookup file %s' % (self.lookup_file_name)
+                )
+
+            # Now insert the OCR original value and variation twice (with original
+            # and variation both as key and value), i.e. swapped
+            #
+            this_org_val_list = self.ocr_val_dict.get(org_val, [])
+            this_org_val_list.append(var_val)
+            self.ocr_val_dict[org_val] = this_org_val_list
+
+            this_org_val_list = self.ocr_val_dict.get(var_val, [])
+            this_org_val_list.append(org_val)
+            self.ocr_val_dict[var_val] = this_org_val_list
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Method which corrupts the given input string by replacing a single
+        character or a sequence of characters with an OCR variation at a
+        position randomly selected by the position function.
+
+        If there are several OCR variations then one will be randomly chosen.
+        """
+
+        if len(in_str) == 0:  # Empty string, no modification possible
+            return in_str
+
+        max_try = 10  # Maximum number of tries to find an OCR modification at a
+        # randomly selected position
+
+        done_ocr_mod = False  # A flag, set to True once a modification is done
+        try_num = 0
+
+        mod_str = in_str[:]  # Make a copy of the string which will be modified
+
+        while (done_ocr_mod == False) and (try_num < max_try):
+
+            mod_pos = self.position_function(mod_str)
+
+            # Try one to three characters at selected position
+            #
+            ocr_org_char_set = set(
+                [
+                    mod_str[mod_pos],
+                    mod_str[mod_pos : mod_pos + 2],
+                    mod_str[mod_pos : mod_pos + 3],
+                ]
+            )
+
+            mod_options = []  # List of possible modifications that can be applied
+
+            for ocr_org_char in ocr_org_char_set:
+                if ocr_org_char in self.ocr_val_dict:
+                    ocr_var_list = self.ocr_val_dict[ocr_org_char]
+                    for mod_val in ocr_var_list:
+                        mod_options.append([ocr_org_char, len(ocr_org_char), mod_val])
+
+            if mod_options != []:  # Modifications are possible
+
+                # Randomly select one of the possible modifications that can be applied
+                #
+                mod_to_apply = random.choice(mod_options)
+                assert mod_to_apply[0] in self.ocr_val_dict.keys()
+                assert mod_to_apply[2] in self.ocr_val_dict.keys()
+
+                mod_str = (
+                    in_str[:mod_pos]
+                    + mod_to_apply[2]
+                    + in_str[mod_pos + mod_to_apply[1] :]
+                )
+
+                done_ocr_mod = True
+
+            else:
+                try_num += 1
+
+        return mod_str
+
+
+# =============================================================================
+
+
+class CorruptValuePhonetic(CorruptValue):
+    """Simulate phonetic errors using a list of phonetic rules which are stored
+    in a CSV look-up file.
+
+    Each line (row) in the CSV file must consist of seven columns that contain
+    the following information:
+    1) Where a phonetic modification can be applied. Possible values are:
+       'ALL','START','END','MIDDLE'
+    2) The original character sequence (i.e. the characters to be replaced)
+    3) The new character sequence (which will replace the original sequence)
+    4) Precondition: A condition that must occur before the original string
+       character sequence in order for this rule to become applicable.
+    5) Postcondition: Similarly, a condition that must occur after the
+       original string character sequence in order for this rule to become
+       applicable.
+    6) Pattern existence condition: This condition requires that a certain
+       given string character sequence does ('y' flag) or does not ('n' flag)
+       occur in the input string.
+    7) Start existence condition: Similarly, this condition requires that the
+       input string starts with a certain string pattern ('y' flag) or not
+       ('n' flag)
+
+    A detailed description of this phonetic data generation is available in
+
+      Accurate Synthetic Generation of Realistic Personal Information
+      Peter Christen and Agus Pudjijono
+      Proceedings of the Pacific-Asia Conference on Knowledge Discovery and
+                         Data Mining (PAKDD), Bangkok, Thailand, April 2009.
+
+    For a given input string, one of the possible phonetic modifications will
+    be randomly selected without the use of the position function.
+
+    The additional arguments (besides the base class argument
+    'position_function') that have to be set when this attribute type is
+    initialised are:
+
+    lookup_file_name  Name of the file which contains the phonetic
+                      modification patterns.
+
+    has_header_line   A flag, set to True or False, that has to be set
+                      according to if the look-up file starts with a header
+                      line or not.
+
+    unicode_encoding  The Unicode encoding (a string name) of the file.
+
+    Note that the 'position_function' is not required by this corruptor
+    method.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.lookup_file_name = None
+        self.has_header_line = None
+        self.unicode_encoding = None
+        self.replace_table = []
+        self.name = 'Phonetic value'
+
+        def dummy_position(s):  # Define a dummy position function
+            return 0
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        base_kwargs['position_function'] = dummy_position
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        # Load the misspelling lookup file - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        # Process values from file and misspellings
+        #
+        for rec_list in lookup_file_data:
+            if len(rec_list) != 7:
+                raise Exception(
+                    'Illegal format in phonetic lookup file %s: %s'
+                    % (self.lookup_file_name, str(rec_list))
+                )
+            val_tuple = ()
+            for val in rec_list:
+                if val != '':
+                    val = val.strip()
+                    val_tuple += (val,)
+                else:
+                    raise Exception(
+                        'Empty value in phonetic lookup file %s" %s'
+                        % (self.lookup_file_name, str(rec_list))
+                    )
+            self.replace_table.append(val_tuple)
+
+    # ---------------------------------------------------------------------------
+
+    def __apply_change__(self, in_str, ch):
+        """Helper function which will apply the selected change to the input
+        string.
+
+        Developed by Agus Pudjijono, ANU, 2008.
+        """
+
+        work_str = in_str
+        list_ch = ch.split('>')
+        subs = list_ch[1]
+        if list_ch[1] == '@':  # @ is blank
+            subs = ''
+        tmp_str = work_str
+        org_pat_length = len(list_ch[0])
+        str_length = len(work_str)
+
+        if list_ch[2] == 'end':
+            org_pat_start = work_str.find(list_ch[0], str_length - org_pat_length)
+        elif list_ch[2] == 'middle':
+            org_pat_start = work_str.find(list_ch[0], 1)
+        else:  # Start and all
+            org_pat_start = work_str.find(list_ch[0], 0)
+
+        if org_pat_start == 0:
+            work_str = subs + work_str[org_pat_length:]
+        elif org_pat_start > 0:
+            work_str = (
+                work_str[:org_pat_start]
+                + subs
+                + work_str[org_pat_start + org_pat_length :]
+            )
+
+        # if (work_str == tmp_str):
+        #   work_str = str_to_change
+
+        return work_str
+
+    # ---------------------------------------------------------------------------
+
+    def __slavo_germanic__(self, in_str):
+        """Helper function which determines if the inputstring could contain a
+        Slavo or Germanic name.
+
+        Developed by Agus Pudjijono, ANU, 2008.
+        """
+
+        if (
+            (in_str.find('w') > -1)
+            or (in_str.find('k') > -1)
+            or (in_str.find('cz') > -1)
+            or (in_str.find('witz') > -1)
+        ):
+            return 1
+        else:
+            return 0
+
+    # ---------------------------------------------------------------------------
+
+    def __collect_replacement__(
+        self, s, where, orgpat, newpat, precond, postcond, existcond, startcond
+    ):
+        """Helper function which collects all the possible phonetic modification
+        patterns that are possible on the given input string, and replaces a
+        pattern in a string.
+
+        The following arguments are needed:
+        - where     Can be one of: 'ALL','START','END','MIDDLE'
+        - precond   Pre-condition (default 'None') can be 'V' for vowel or
+                    'C' for consonant
+        - postcond  Post-condition (default 'None') can be 'V' for vowel or
+                    'C' for consonant
+
+        Developed by Agus Pudjijono, ANU, 2008.
+        """
+
+        vowels = 'aeiouy'
+        tmpstr = s
+        changesstr = ''
+
+        start_search = 0  # Position from where to start the search
+        pat_len = len(orgpat)
+        stop = False
+
+        # As long as pattern is in string
+        #
+        while (orgpat in tmpstr[start_search:]) and (stop == False):
+
+            pat_start = tmpstr.find(orgpat, start_search)
+            str_len = len(tmpstr)
+
+            # Check conditions of previous and following character
+            #
+            OKpre = False  # Previous character condition
+            OKpre1 = False  # Previous character1 condition
+            OKpre2 = False  # Previous character2 condition
+
+            OKpost = False  # Following character condition
+            OKpost1 = False  # Following character1 condition
+            OKpost2 = False  # Following character2 condition
+
+            OKexist = False  # Existing pattern condition
+            OKstart = False  # Existing start pattern condition
+
+            index = 0
+
+            if precond == 'None':
+                OKpre = True
+
+            elif pat_start > 0:
+                if ((precond == 'V') and (tmpstr[pat_start - 1] in vowels)) or (
+                    (precond == 'C') and (tmpstr[pat_start - 1] not in vowels)
+                ):
+                    OKpre = True
+
+                elif (precond.find(';')) > -1:
+                    if precond.find('|') > -1:
+                        rls = precond.split('|')
+                        rl1 = rls[0].split(';')
+
+                        if int(rl1[1]) < 0:
+                            index = pat_start + int(rl1[1])
+                        else:
+                            index = pat_start + (len(orgpat) - 1) + int(rl1[1])
+
+                        i = 2
+                        if rl1[0] == 'n':
+                            while i < (len(rl1)):
+                                if tmpstr[index : (index + len(rl1[i]))] == rl1[i]:
+                                    OKpre1 = False
+                                    break
+                                else:
+                                    OKpre1 = True
+                                i += 1
+                        else:
+                            while i < (len(rl1)):
+                                if tmpstr[index : (index + len(rl1[i]))] == rl1[i]:
+                                    OKpre1 = True
+                                    break
+                                i += 1
+
+                        rl2 = rls[1].split(';')
+
+                        if int(rl2[1]) < 0:
+                            index = pat_start + int(rl2[1])
+                        else:
+                            index = pat_start + (len(orgpat) - 1) + int(rl2[1])
+
+                        i = 2
+                        if rl2[0] == 'n':
+                            while i < (len(rl2)):
+                                if tmpstr[index : (index + len(rl2[i]))] == rl2[i]:
+                                    OKpre2 = False
+                                    break
+                                else:
+                                    OKpre2 = True
+                                i += 1
+                        else:
+                            while i < (len(rl2)):
+                                if tmpstr[index : (index + len(rl2[i]))] == rl2[i]:
+                                    OKpre2 = True
+                                    break
+                                i += 1
+
+                        OKpre = OKpre1 and OKpre2
+
+                    else:
+                        rl = precond.split(';')
+                        # -
+                        if int(rl[1]) < 0:
+                            index = pat_start + int(rl[1])
+                        else:
+                            index = pat_start + (len(orgpat) - 1) + int(rl[1])
+
+                        i = 2
+                        if rl[0] == 'n':
+                            while i < (len(rl)):
+                                if tmpstr[index : (index + len(rl[i]))] == rl[i]:
+                                    OKpre = False
+                                    break
+                                else:
+                                    OKpre = True
+                                i += 1
+                        else:
+                            while i < (len(rl)):
+                                if tmpstr[index : (index + len(rl[i]))] == rl[i]:
+                                    OKpre = True
+                                    break
+                                i += 1
+
+            if postcond == 'None':
+                OKpost = True
+
+            else:
+                pat_end = pat_start + pat_len
+
+                if pat_end < str_len:
+                    if ((postcond == 'V') and (tmpstr[pat_end] in vowels)) or (
+                        (postcond == 'C') and (tmpstr[pat_end] not in vowels)
+                    ):
+                        OKpost = True
+                    elif (postcond.find(';')) > -1:
+                        if postcond.find('|') > -1:
+                            rls = postcond.split('|')
+
+                            rl1 = rls[0].split(';')
+
+                            if int(rl1[1]) < 0:
+                                index = pat_start + int(rl1[1])
+                            else:
+                                index = pat_start + (len(orgpat) - 1) + int(rl1[1])
+
+                            i = 2
+                            if rl1[0] == 'n':
+                                while i < (len(rl1)):
+                                    if tmpstr[index : (index + len(rl1[i]))] == rl1[i]:
+                                        OKpost1 = False
+                                        break
+                                    else:
+                                        OKpost1 = True
+                                    i += 1
+                            else:
+                                while i < (len(rl1)):
+                                    if tmpstr[index : (index + len(rl1[i]))] == rl1[i]:
+                                        OKpost1 = True
+                                        break
+                                    i += 1
+
+                            rl2 = rls[1].split(';')
+
+                            if int(rl2[1]) < 0:
+                                index = pat_start + int(rl2[1])
+                            else:
+                                index = pat_start + (len(orgpat) - 1) + int(rl2[1])
+
+                            i = 2
+                            if rl2[0] == 'n':
+                                while i < (len(rl2)):
+                                    if tmpstr[index : (index + len(rl2[i]))] == rl2[i]:
+                                        OKpost2 = False
+                                        break
+                                    else:
+                                        OKpost2 = True
+                                    i += 1
+                            else:
+                                while i < (len(rl2)):
+                                    if tmpstr[index : (index + len(rl2[i]))] == rl2[i]:
+                                        OKpost2 = True
+                                        break
+                                    i += 1
+
+                            OKpost = OKpost1 and OKpost2
+
+                        else:
+                            rl = postcond.split(';')
+
+                            if int(rl[1]) < 0:
+                                index = pat_start + int(rl[1])
+                            else:
+                                index = pat_start + (len(orgpat) - 1) + int(rl[1])
+
+                            i = 2
+                            if rl[0] == 'n':
+                                while i < (len(rl)):
+                                    if tmpstr[index : (index + len(rl[i]))] == rl[i]:
+                                        OKpost = False
+                                        break
+                                    else:
+                                        OKpost = True
+                                    i += 1
+                            else:
+                                while i < (len(rl)):
+                                    if tmpstr[index : (index + len(rl[i]))] == rl[i]:
+                                        OKpost = True
+                                        break
+                                    i += 1
+
+            if existcond == 'None':
+                OKexist = True
+
+            else:
+                rl = existcond.split(';')
+                if rl[1] == 'slavo':
+                    r = self.__slavo_germanic__(s)
+                    if rl[0] == 'n':
+                        if r == 0:
+                            OKexist = True
+                    else:
+                        if r == 1:
+                            OKexist = True
+                else:
+                    i = 1
+                    if rl[0] == 'n':
+                        while i < (len(rl)):
+                            if s.find(rl[i]) > -1:
+                                OKexist = False
+                                break
+                            else:
+                                OKexist = True
+                            i += i
+                    else:
+                        while i < (len(rl)):
+                            if s.find(rl[i]) > -1:
+                                OKexist = True
+                                break
+                            i += i
+
+            if startcond == 'None':
+                OKstart = True
+
+            else:
+                rl = startcond.split(';')
+                i = 1
+                if rl[0] == 'n':
+                    while i < (len(rl)):
+                        if s.find(rl[i]) > -1:
+                            OKstart = False
+                            break
+                        else:
+                            OKstart = True
+                        i += i
+                else:
+                    while i < (len(rl)):
+                        if s.find(rl[i]) == 0:
+                            OKstart = True
+                            break
+                        i += i
+
+            # Replace pattern if conditions and position OK
+            #
+            if (
+                (OKpre == True)
+                and (OKpost == True)
+                and (OKexist == True)
+                and (OKstart == True)
+            ) and (
+                ((where == 'START') and (pat_start == 0))
+                or (
+                    (where == 'MIDDLE')
+                    and (pat_start > 0)
+                    and (pat_start + pat_len < str_len)
+                )
+                or ((where == 'END') and (pat_start + pat_len == str_len))
+                or (where == 'ALL')
+            ):
+                tmpstr = tmpstr[:pat_start] + newpat + tmpstr[pat_start + pat_len :]
+                changesstr += ',' + orgpat + '>' + newpat + '>' + where.lower()
+                start_search = pat_start + len(newpat)
+
+            else:
+                start_search = pat_start + 1
+
+            if start_search >= (len(tmpstr) - 1):
+                stop = True
+
+        tmpstr += changesstr
+
+        return tmpstr
+
+    # ---------------------------------------------------------------------------
+
+    def __get_transformation__(self, in_str):
+        """Helper function which generates the list of possible phonetic
+        modifications for the given input string.
+
+        Developed by Agus Pudjijono, ANU, 2008.
+        """
+
+        if in_str == '':
+            return in_str
+
+        changesstr2 = ''
+
+        workstr = in_str
+
+        for rtpl in self.replace_table:  # Check all transformations in the table
+            if len(rtpl) == 3:
+                rtpl += ('None', 'None', 'None', 'None')
+
+            workstr = self.__collect_replacement__(
+                in_str, rtpl[0], rtpl[1], rtpl[2], rtpl[3], rtpl[4], rtpl[5], rtpl[6]
+            )
+            if workstr.find(',') > -1:
+                tmpstr = workstr.split(',')
+                workstr = tmpstr[0]
+                if changesstr2.find(tmpstr[1]) == -1:
+                    changesstr2 += tmpstr[1] + ';'
+        workstr += ',' + changesstr2
+
+        return workstr
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Method which corrupts the given input string by applying a phonetic
+        modification.
+
+        If several such modifications are possible then one will be randomly
+        selected.
+        """
+
+        if len(in_str) == 0:  # Empty string, no modification possible
+            return in_str
+
+        # Get the possible phonetic modifications for this input string
+        #
+        phonetic_changes = self.__get_transformation__(in_str)
+
+        mod_str = in_str
+
+        if ',' in phonetic_changes:  # Several modifications possible
+            tmp_str = phonetic_changes.split(',')
+            pc = tmp_str[1][:-1]  # Remove the last ';'
+            list_pc = pc.split(';')
+            change_op = random.choice(list_pc)
+            if change_op != '':
+                mod_str = self.__apply_change__(in_str, change_op)
+                # print in_str, mod_str, change_op
+
+        return mod_str
+
+
+# =============================================================================
+
+
+class CorruptCategoricalValue(CorruptValue):
+    """Replace a categorical value with another categorical value from the same
+    look-up file.
+
+    This corruptor can be used to modify attribute values with known
+    misspellings.
+
+    The look-up file is a CSV file with two columns, the first is a
+    categorical value that is expected to be in an attribute in an original
+    record, and the second is a variation of this categorical value.
+
+    It is possible for an 'original' categorical value (first column) to have
+    several misspelling variations (second column). In such a case one
+    misspelling will be randomly selected.
+
+    The additional arguments (besides the base class argument
+    'position_function') that have to be set when this attribute type is
+    initialised are:
+
+    lookup_file_name  Name of the file which contains the categorical values
+                      and their misspellings.
+
+    has_header_line   A flag, set to True or False, that has to be set
+                      according to if the look-up file starts with a header
+                      line or not.
+
+    unicode_encoding  The Unicode encoding (a string name) of the file.
+
+    Note that the 'position_function' is not required by this corruptor
+    method.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.lookup_file_name = None
+        self.has_header_line = None
+        self.unicode_encoding = None
+        self.misspell_dict = {}  # The dictionary to hold the misspellings
+        self.name = 'Categorial value'
+
+        def dummy_position(s):  # Define a dummy position function
+            return 0
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        base_kwargs['position_function'] = dummy_position
+
+        CorruptValue.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        # Load the misspelling lookup file - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        # Process values from file and misspellings
+        #
+        for rec_list in lookup_file_data:
+            if len(rec_list) != 2:
+                raise Exception(
+                    'Illegal format in misspellings lookup file %s: %s'
+                    % (self.lookup_file_name, str(rec_list))
+                )
+
+            org_val = rec_list[0].strip()
+            if org_val == '':
+                raise Exception(
+                    'Empty original attribute value in lookup file %s'
+                    % (self.lookup_file_name)
+                )
+            misspell_val = rec_list[1].strip()
+            if misspell_val == '':
+                raise Exception(
+                    'Empty misspelled attribute value in lookup '
+                    + 'file %s' % (self.lookup_file_name)
+                )
+            if org_val == misspell_val:
+                raise Exception(
+                    'Misspelled value is the same as original value'
+                    + ' in lookup file %s' % (self.lookup_file_name)
+                )
+
+            this_org_val_list = self.misspell_dict.get(org_val, [])
+            this_org_val_list.append(misspell_val)
+            self.misspell_dict[org_val] = this_org_val_list
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_value(self, in_str):
+        """Method which corrupts the given input string and replaces it with a
+        misspelling, if there is a known misspelling for the given original
+        value.
+
+        If there are several known misspellings for the given original value
+        then one will be randomly selected.
+        """
+
+        if len(in_str) == 0:  # Empty string, no modification possible
+            return in_str
+
+        if in_str not in self.misspell_dict:  # No misspelling for this value
+            return in_str
+
+        misspell_list = self.misspell_dict[in_str]
+
+        return random.choice(misspell_list)
+
+
+# =============================================================================
+
+
+class CorruptDataSet:
+    """Class which provides methods to corrupt the original records generated by
+    one of the classes derived from the GenerateDataSet base class.
+
+    The following arguments need to be set when a GenerateDataSet instance is
+    initialised:
+
+    number_of_mod_records  The number of modified (corrupted) records that are
+                           to be generated. This will correspond to the number
+                           of 'duplicate' records that are generated.
+
+    number_of_org_records  The number of original records that were generated
+                           by the GenerateDataSet class.
+
+    attribute_name_list    The list of attributes (fields) that have been
+                           generated for each record.
+
+    max_num_dup_per_rec    The maximum number of modified (corrupted) records
+                           that can be generated for a single original record.
+
+    num_dup_dist           The probability distribution used to create the
+                           duplicate records for one original record (possible
+                           distributions are: 'uniform', 'poisson', 'zipf')
+
+    max_num_mod_per_attr   The maximum number of modifications are to be
+                           applied on a single attribute.
+
+    num_mod_per_rec        The number of modification that are to be applied
+                           to a record
+
+    attr_mod_prob_dict     This dictionary contains probabilities that
+                           determine how likely an attribute is selected for
+                           random modification (corruption).
+                           Keys are attribute names and values are probability
+                           values. The sum of the given probabilities must sum
+                           to 1.0.
+                           Not all attributes need to be listed in this
+                           dictionary, only the ones onto which modifications
+                           are to be applied.
+                           An example of such a dictionary is given below.
+
+    attr_mod_data_dict     A dictionary which contains for each attribute that
+                           is to be modified a list which contains as pairs of
+                           probabilities and corruptor objects (i.e. objects
+                           based on any of the classes derived from base class
+                           CorruptValue).
+                           For each attribute listed, the sum of probabilities
+                           given in its list must sum to 1.0.
+                           An example of such a dictionary is given below.
+
+    Example for 'attr_mod_prob_dict':
+
+    attr_mod_prob_dict = {'surname':0.4, 'address':0.6}
+
+    In this example, the surname attribute will be selected for modification
+    with a 40% likelihood and the address attribute with a 60% likelihood.
+
+    Example for 'attr_mod_data_dict':
+
+    attr_mod_data_dict = {'surname':[(0.25,corrupt_ocr), (0.50:corrupt_edit),
+                                     (0.25:corrupt_keyboard)],
+                          'address':[(0.50:corrupt_ocr), (0.20:missing_value),
+                                     (0.25:corrupt_keyboard)]}
+
+    In this example, if the 'surname' is selected for modification, with a
+    25% likelihood an OCR modification will be applied, with 50% likelihood a
+    character edit modification will be applied, and with 25% likelihood a
+    keyboard typing error modification will be applied.
+    If the 'address' attribute is selected, then with 50% likelihood an OCR
+    modification will be applied, with 20% likelihood a value will be set to
+    a missing value, and with 25% likelihood a keyboard typing error
+    modification will be applied.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor, set attributes."""
+
+        self.number_of_mod_records = None
+        self.number_of_org_records = None
+        self.attribute_name_list = None
+        self.max_num_dup_per_rec = None
+        self.num_dup_dist = None
+        self.num_mod_per_rec = None
+        self.max_num_mod_per_attr = None
+        self.attr_mod_prob_dict = None
+        self.attr_mod_data_dict = None
+
+        # Process the keyword arguments
+        #
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('number_of_m'):
+                basefunctions.check_is_integer('number_of_mod_records', value)
+                basefunctions.check_is_positive('number_of_mod_records', value)
+                self.number_of_mod_records = value
+
+            elif keyword.startswith('number_of_o'):
+                basefunctions.check_is_integer('number_of_org_records', value)
+                basefunctions.check_is_positive('number_of_org_records', value)
+                self.number_of_org_records = value
+
+            elif keyword.startswith('attribute'):
+                basefunctions.check_is_list('attribute_name_list', value)
+                self.attribute_name_list = value
+
+            elif keyword.startswith('max_num_dup'):
+                basefunctions.check_is_integer('max_num_dup_per_rec', value)
+                basefunctions.check_is_positive('max_num_dup_per_rec', value)
+                self.max_num_dup_per_rec = value
+
+            elif keyword.startswith('num_dup_'):
+                if value not in ['uniform', 'poisson', 'zipf']:
+                    raise Exception(
+                        'Illegal value given for "num_dup_dist": %s' % (str(value))
+                    )
+                self.num_dup_dist = value
+
+            elif keyword.startswith('num_mod_per_r'):
+                basefunctions.check_is_integer('num_mod_per_rec', value)
+                basefunctions.check_is_positive('num_mod_per_rec', value)
+                self.num_mod_per_rec = value
+
+            elif keyword.startswith('max_num_mod_per_a'):
+                basefunctions.check_is_integer('max_num_mod_per_attr', value)
+                basefunctions.check_is_positive('max_num_mod_per_attr', value)
+                self.max_num_mod_per_attr = value
+
+            elif keyword.startswith('attr_mod_p'):
+                basefunctions.check_is_dictionary('attr_mod_prob_dict', value)
+                self.attr_mod_prob_dict = value
+
+            elif keyword.startswith('attr_mod_d'):
+                basefunctions.check_is_dictionary('attr_mod_data_dict', value)
+                self.attr_mod_data_dict = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_integer('number_of_mod_records', self.number_of_mod_records)
+        basefunctions.check_is_positive(
+            'number_of_mod_records', self.number_of_mod_records
+        )
+        basefunctions.check_is_integer('number_of_org_records', self.number_of_org_records)
+        basefunctions.check_is_positive(
+            'number_of_org_records', self.number_of_org_records
+        )
+        basefunctions.check_is_list('attribute_name_list', self.attribute_name_list)
+        basefunctions.check_is_integer('max_num_dup_per_rec', self.max_num_dup_per_rec)
+        basefunctions.check_is_positive('max_num_dup_per_rec', self.max_num_dup_per_rec)
+        basefunctions.check_is_string('num_dup_dist', self.num_dup_dist)
+        basefunctions.check_is_integer('num_mod_per_rec', self.num_mod_per_rec)
+        basefunctions.check_is_positive('num_mod_per_rec', self.num_mod_per_rec)
+        basefunctions.check_is_integer('max_num_mod_per_attr', self.max_num_mod_per_attr)
+        basefunctions.check_is_positive('max_num_mod_per_attr', self.max_num_mod_per_attr)
+        if self.max_num_mod_per_attr > self.num_mod_per_rec:
+            raise Exception(
+                'Number of modifications per record must be larger'
+                + ' than maximum number of modifications per attribute'
+            )
+        basefunctions.check_is_dictionary('attr_mod_prob_dict', self.attr_mod_prob_dict)
+        basefunctions.check_is_dictionary('attr_mod_data_dict', self.attr_mod_data_dict)
+
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        # Check if it is possible to generate the desired number of modified
+        # (duplicate) corrupted records
+        #
+        if (
+            self.number_of_mod_records
+            > self.number_of_org_records * self.max_num_dup_per_rec
+        ):
+            raise Exception(
+                'Desired number of duplicates cannot be generated '
+                + 'with given number of original records and maximum'
+                + ' number of duplicates per original record'
+            )
+
+        # Check if there are enough attributes given for modifications - - - - - -
+        #
+        if len(self.attr_mod_prob_dict) < self.num_mod_per_rec:
+            raise Exception(
+                'Not enough attribute modifications given to obtain'
+                + ' the desired number of modifications per record'
+            )
+
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        # Create a distribution for the number of duplicates for an original record
+        #
+        num_dup = 1
+        prob_sum = 0.0
+        self.prob_dist_list = [(num_dup, prob_sum)]
+
+        if self.num_dup_dist == 'uniform':
+            uniform_val = 1.0 / float(self.max_num_dup_per_rec)
+
+            for i in range(self.max_num_dup_per_rec - 1):
+                num_dup += 1
+                self.prob_dist_list.append(
+                    (num_dup, uniform_val + self.prob_dist_list[-1][1])
+                )
+
+        elif self.num_dup_dist == 'poisson':
+
+            def fac(n):  # Factorial of an integer number (recursive calculation)
+                if n > 1.0:
+                    return n * fac(n - 1.0)
+                else:
+                    return 1.0
+
+            poisson_num = []  # A list of poisson numbers
+            poisson_sum = 0.0  # The sum of all poisson number
+
+            # The mean (lambda) for the poisson numbers
+            #
+            mean = 1.0 + (
+                float(self.number_of_mod_records) / float(self.number_of_org_records)
+            )
+
+            for i in range(self.max_num_dup_per_rec):
+                poisson_num.append((math.exp(-mean) * (mean**i)) / fac(i))
+                poisson_sum += poisson_num[-1]
+
+            for i in range(self.max_num_dup_per_rec):  # Scale so they sum up to 1.0
+                poisson_num[i] = poisson_num[i] / poisson_sum
+
+            for i in range(self.max_num_dup_per_rec - 1):
+                num_dup += 1
+                self.prob_dist_list.append(
+                    (num_dup, poisson_num[i] + self.prob_dist_list[-1][1])
+                )
+
+        elif self.num_dup_dist == 'zipf':
+            zipf_theta = 0.5
+
+            denom = 0.0
+            for i in range(self.number_of_org_records):
+                denom += 1.0 / (i + 1) ** (1.0 - zipf_theta)
+
+            zipf_c = 1.0 / denom
+            zipf_num = []  # A list of Zipf numbers
+            zipf_sum = 0.0  # The sum of all Zipf number
+
+            for i in range(self.max_num_dup_per_rec):
+                zipf_num.append(zipf_c / ((i + 1) ** (1.0 - zipf_theta)))
+                zipf_sum += zipf_num[-1]
+
+            for i in range(self.max_num_dup_per_rec):  # Scale so they sum up to 1.0
+                zipf_num[i] = zipf_num[i] / zipf_sum
+
+            for i in range(self.max_num_dup_per_rec - 1):
+                num_dup += 1
+                self.prob_dist_list.append(
+                    (num_dup, zipf_num[i] + self.prob_dist_list[-1][1])
+                )
+
+        print('Probability distribution for number of duplicates per record:')
+        print(self.prob_dist_list)
+
+        # Check probability list for attributes and dictionary for attributes - - -
+        # if they sum to 1.0
+        #
+        attr_prob_sum = sum(self.attr_mod_prob_dict.values())
+        if abs(attr_prob_sum - 1.0) > 0.0000001:
+            raise Exception(
+                'Attribute modification probabilities do not sum '
+                + 'to 1.0: %f' % (attr_prob_sum)
+            )
+        for attr_name in self.attr_mod_prob_dict:
+            assert (
+                self.attr_mod_prob_dict[attr_name] >= 0.0
+            ), 'Negative probability given in "attr_mod_prob_dict"'
+            if attr_name not in self.attribute_name_list:
+                raise Exception(
+                    'Attribute name "%s" in "attr_mod_prob_dict" not ' % (attr_name)
+                    + 'listed in "attribute_name_list"'
+                )
+
+        # Check details of attribute modification data dictionary
+        #
+        for (attr_name, attr_mod_data_list) in self.attr_mod_data_dict.items():
+            if attr_name not in self.attribute_name_list:
+                raise Exception(
+                    'Attribute name "%s" in "attr_mod_data_dict" not ' % (attr_name)
+                    + 'listed in "attribute_name_list"'
+                )
+            basefunctions.check_is_list('attr_mod_data_dict entry', attr_mod_data_list)
+            prob_sum = 0.0
+            for list_elem in attr_mod_data_list:
+                basefunctions.check_is_tuple('attr_mod_data_dict list element', list_elem)
+                assert len(list_elem) == 2, (
+                    'attr_mod_data_dict list element does ' + 'not consist of two elements'
+                )
+                basefunctions.check_is_normalised(
+                    'attr_mod_data_dict list probability', list_elem[0]
+                )
+                prob_sum += list_elem[0]
+            if abs(prob_sum - 1.0) > 0.0000001:
+                raise Exception(
+                    'Probability sum is no 1.0 for attribute "%s"' % (attr_name)
+                )
+
+        # Generate a list with attribute probabilities summed for easy selection
+        #
+        self.attr_mod_prob_list = []
+        prob_sum = 0
+        for (attr_name, attr_prob) in self.attr_mod_prob_dict.items():
+            prob_sum += attr_prob
+            self.attr_mod_prob_list.append([prob_sum, attr_name])
+        # print self.attr_mod_prob_list
+
+    # ---------------------------------------------------------------------------
+
+    def corrupt_records(self, rec_dict):
+        """Method to corrupt modify the records in the given record dictionary
+        according to the settings of the data set corruptor.
+        """
+
+        # Check if number of records given is what is expected
+        #
+        assert self.number_of_org_records == len(
+            rec_dict
+        ), 'Illegal number of records to modify given'
+
+        # First generate for each original record the number of duplicates that are
+        # to be generated for it.
+        #
+        dup_rec_num_dict = {}  # Keys are the record identifiers of the original
+        # records, value their number of duplicates
+        total_num_dups = 0  # Total number of duplicates generated
+
+        org_rec_id_list = list(rec_dict.keys())
+        random.shuffle(org_rec_id_list)
+
+        org_rec_i = 0  # Loop counter over which record to assign duplicates to
+
+        while (org_rec_i < self.number_of_org_records) and (
+            total_num_dups < self.number_of_mod_records
+        ):
+
+            # Randomly choose how many duplicates to create for this original record
+            #
+            r = random.random()  # Random number between 0.0 and 1.0
+            ind = -1
+            while self.prob_dist_list[ind][1] > r:
+                ind -= 1
+            num_dups = self.prob_dist_list[ind][0]
+
+            assert (num_dups > 0) and (num_dups <= self.max_num_dup_per_rec)
+
+            # Check if there are still 'enough' duplicates to generate
+            #
+            if num_dups <= (self.number_of_mod_records - total_num_dups):
+
+                # Select next record for which to generate duplicates
+                #
+                org_rec_id = org_rec_id_list[org_rec_i]
+                org_rec_i += 1
+                dup_rec_num_dict[org_rec_id] = num_dups
+                total_num_dups += num_dups
+
+        assert total_num_dups == sum(dup_rec_num_dict.values())
+
+        # Deal with the case where every original record has a number of duplicates
+        # but not enough duplicates are generated in total
+        #
+        org_rec_id_list = list(rec_dict.keys())
+        random.shuffle(org_rec_id_list)
+
+        while total_num_dups < self.number_of_mod_records:
+            org_rec_id = random.choice(org_rec_id_list)
+
+            # If possible, increase number of duplicates for this record by 1
+            #
+            if dup_rec_num_dict[org_rec_id] < self.max_num_dup_per_rec:
+                dup_rec_num_dict[org_rec_id] = dup_rec_num_dict[org_rec_id] + 1
+                total_num_dups += 1
+
+        assert sum(dup_rec_num_dict.values()) == self.number_of_mod_records
+
+        # Generate a histogram of number of duplicates per record
+        #
+        dup_histo = {}
+        for (org_rec_id_to_mod, num_dups) in dup_rec_num_dict.items():
+            dup_count = dup_histo.get(num_dups, 0) + 1
+            dup_histo[num_dups] = dup_count
+        print(
+            'Distribution of number of original records with certain number '
+            + 'of duplicates:'
+        )
+        dup_histo_keys = list(dup_histo.keys())
+        dup_histo_keys.sort()
+        for num_dups in dup_histo_keys:
+            print(
+                ' Number of records with %d duplicates: %d'
+                % (num_dups, dup_histo[num_dups])
+            )
+        print()
+
+        num_dup_rec_created = 0  # Count how many duplicate records have been
+        # generated
+
+        # Main loop over all original records for which to generate duplicates - -
+        #
+        for (org_rec_id_to_mod, num_dups) in dup_rec_num_dict.items():
+            assert (num_dups > 0) and (num_dups <= self.max_num_dup_per_rec)
+
+            print()
+            print(
+                'Generating %d modified (duplicate) records for record "%s"'
+                % (num_dups, org_rec_id_to_mod)
+            )
+
+            rec_to_mod_list = rec_dict[org_rec_id_to_mod]
+
+            d = 0  # Loop counter for duplicates for this record
+
+            this_dup_rec_list = []  # A list of all duplicates for this record
+
+            # Loop to create duplicate records - - - - - - - - - - - - - - - - - - - -
+            #
+            while d < num_dups:
+
+                # Create a duplicate of the original record
+                #
+                dup_rec_list = rec_to_mod_list[:]  # Make copy of original record
+
+                org_rec_num = org_rec_id_to_mod.split('-')[1]
+                dup_rec_id = 'rec-%s-dup-%d' % (org_rec_num, d)
+                print(
+                    '  Generate identifier for duplicate record based on "%s": %s'
+                    % (org_rec_id_to_mod, dup_rec_id)
+                )
+
+                # Count the number of modifications in this record (counted as the
+                # number of modified attributes)
+                #
+                num_mod_in_record = 0
+
+                # Set the attribute modification counters to zero for all attributes
+                # that can be modified
+                #
+                attr_mod_count_dict = {}
+                for attr_name in self.attr_mod_prob_dict.keys():
+                    attr_mod_count_dict[attr_name] = 0
+
+                # Abort generating modifications after a larger number of tries to
+                # prevent an endless loop
+                #
+                max_num_tries = self.num_mod_per_rec * 10
+                num_tries = 0
+
+                # Now apply desired number of modifications to this record
+                #
+                while (num_mod_in_record < self.num_mod_per_rec) and (
+                    num_tries < max_num_tries
+                ):
+
+                    # Randomly modify an attribute value
+                    #
+                    r = random.random()  # Random value between 0.0 and 1.0
+                    i = 0
+                    while self.attr_mod_prob_list[i][0] < r:
+                        i += 1
+                    mod_attr_name = self.attr_mod_prob_list[i][1]
+
+                    if attr_mod_count_dict[mod_attr_name] < self.max_num_mod_per_attr:
+                        mod_attr_name_index = self.attribute_name_list.index(mod_attr_name)
+                        mod_attr_val = dup_rec_list[mod_attr_name_index]
+
+                        # Select an attribute to modify according to probability
+                        # distribution of corruption methods
+                        #
+                        attr_mod_data_list = self.attr_mod_data_dict[mod_attr_name]
+
+                        r = random.random()  # Random value between 0.0 and 1.0
+                        p_sum = attr_mod_data_list[0][0]
+                        i = 0
+                        while r >= p_sum:
+                            i += 1
+                            p_sum += attr_mod_data_list[i][0]
+                        corruptor_method = attr_mod_data_list[i][1]
+
+                        # Modify the value from the selected attribute
+                        #
+                        new_attr_val = corruptor_method.corrupt_value(mod_attr_val)
+
+                        org_attr_val = rec_to_mod_list[mod_attr_name_index]
+
+                        # If the modified value is different insert it back into modified
+                        # record
+                        #
+                        if new_attr_val != org_attr_val:
+                            print('  Selected attribute for modification:', mod_attr_name)
+                            print('    Selected corruptor:', corruptor_method.name)
+
+                            # The following weird string printing construct is to overcome
+                            # problems with printing non-ASCII characters
+                            #
+                            print(
+                                '      Original attribute value:',
+                                str([org_attr_val])[1:-1],
+                            )
+                            print(
+                                '      Modified attribute value:',
+                                str([new_attr_val])[1:-1],
+                            )
+
+                            dup_rec_list[mod_attr_name_index] = new_attr_val
+
+                            # One more modification for this attribute
+                            #
+                            attr_mod_count_dict[mod_attr_name] += 1
+
+                            # The number of modifications in a record corresponds to the
+                            # number of modified attributes
+                            #
+                            num_mod_in_record = 0
+
+                            for num_attr_mods in attr_mod_count_dict.values():
+                                if num_attr_mods > 0:
+                                    num_mod_in_record += 1  # One more modification
+                            assert num_mod_in_record <= self.num_mod_per_rec
+
+                        num_tries += 1  # One more try to modify record
+
+                # Check if this duplicate is different from all others for this original
+                # record
+                #
+                is_diff = True  # Flag to check if the latest duplicate is different
+
+                if this_dup_rec_list == []:  # No duplicate so far
+                    this_dup_rec_list.append(dup_rec_list)
+                else:
+                    for check_dup_rec in this_dup_rec_list:
+                        if check_dup_rec == dup_rec_list:  # Same as a previous duplicate
+                            is_diff = False
+                            print('Same duplicate:', check_dup_rec)
+                            print('               ', dup_rec_list)
+
+                if is_diff == True:  # Only keep duplicate records that are different
+
+                    # Safe the record into the overall record dictionary
+                    #
+                    rec_dict[dup_rec_id] = dup_rec_list
+
+                    d += 1
+                    num_dup_rec_created += 1
+
+                    print('Original record:')
+                    print(' ', rec_to_mod_list)
+                    print(
+                        'Record with %d modified attributes' % (num_mod_in_record),
+                    )
+                    attr_mod_str = '('
+                    for a in self.attribute_name_list:
+                        if attr_mod_count_dict.get(a, 0) > 0:
+                            attr_mod_str += '%d in %s, ' % (attr_mod_count_dict[a], a)
+                    attr_mod_str = attr_mod_str[:-1] + '):'
+                    print(attr_mod_str)
+                    print(' ', dup_rec_list)
+                    print(
+                        '%d of %d duplicate records generated so far'
+                        % (num_dup_rec_created, self.number_of_mod_records)
+                    )
+                    print()
+
+        return rec_dict
+
+
+# =============================================================================

geco_data_generator/data/age-freq.csv

@@ -0,0 +1,17 @@
+# Example age distribution
+#
+
+0,10
+1,11
+2,12
+3,14
+4,15
+5,
+6,
+7,
+
+..
+
+99,1
+100,0.5
+120,1

geco_data_generator/data/city-gender-bloodpressure.csv

@@ -0,0 +1,13 @@
+#
+canberra,10
+m,50,normal,120,12,None,None
+f,50,normal,110,23,None,None
+sydney,45
+m,45,normal,130,24,None,None
+f,55,normal,105,40,None,None
+melbourne,35
+f,45,normal,105,16,None,None
+m,55,normal,117,19,None,None
+hobart,10
+f,55,normal,100,10,None,None
+m,48,normal,105,24,None,None

geco_data_generator/data/gender-bloodpressure.csv

@@ -0,0 +1,5 @@
+# Categorical-continuous attribute gender- blood pressure 
+#
+m,40,normal,120,12,None,None
+f,35,normal,110,23,None,None
+n/a,25,normal,115,18,None,None

geco_data_generator/data/gender-city-income.csv

@@ -0,0 +1,13 @@
+# Look-up file for generating a compound attribute: gender / city / income. For details
+# see module generator.py, class GenerateCateCateContCompoundAttribute
+#
+male,60
+canberra,20,uniform,50000,90000
+sydney,30,normal,75000,50000,20000,None
+melbourne,30,uniform,35000,200000
+perth,20,normal,55000,250000,15000,None
+female,40
+canberra,10,normal,45000,10000,None,150000
+sydney,40,uniform,60000,200000
+melbourne,20,uniform,50000,1750000
+brisbane,30,normal,55000,20000,20000,100000

geco_data_generator/data/gender-city-japanese.csv

@@ -0,0 +1,10 @@
+# The first line in this look-up file is a header line
+# Look-up file for generating a compound attribute: gender / city. For details
+# see module generator.py, class GenerateCateCateCompoundAttribute
+#
+�j��,60,���l,7, \
+����,30,���,45, \
+���,18
+����,40,���l,10,����,40, \
+���,20,��t,30,�Q�n,5,\
+���h,20

geco_data_generator/data/gender-city.csv

@@ -0,0 +1,11 @@
+cate1,count-cate1,cate2,count-cate2
+# The first line in this look-up file is a header line
+# Look-up file for generating a compound attribute: gender / city. For details
+# see module generator.py, class GenerateCateCateCompoundAttribute
+#
+male,60,canberra,7, \
+sydney,30,melbourne,45, \
+perth,18
+female,40,canberra,10,sydney,40, \
+melbourne,20,brisbane,30,hobart,5,\
+perth,20

geco_data_generator/data/gender-income-data.csv

@@ -0,0 +1,6 @@
+#
+male,55,10000-25000,15, 25000-50000,25, 50000-80000,20,\
+80000-120000,20, 120000-160000,10,160000-1000000,10
+female,45,10000-25000,20, 25000-50000,35, 50000-80000,25,\
+80000-120000,10, 120000-160000,5,160000-1000000,5
+

geco_data_generator/data/gender-income.csv

@@ -0,0 +1,6 @@
+# Look-up file for generating a compound attribute: gender / income. For details
+# see module generator.py, class GenerateCateContCompoundAttribute
+#
+m,30,uniform,20000,100000  
+f,40,normal,35000,100000,10000,None
+na,30,normal,55000,45000,0,150000

geco_data_generator/data/givenname_f_freq.csv

@@ -0,0 +1,529 @@
+# =============================================================================
+# givenname_f_freq.csv - Frequency table for female given names
+#
+# Sources: - Compiled from various web sites
+#
+# Last update: 11/04/2002, Peter Christen
+# =============================================================================
+
+# =============================================================================
+# This table is in a two-column comma separated format, with the first column
+# being the names and the second a corresponding frequency count. 
+# =============================================================================
+
+aaliyah,1
+abbey,9
+abbie,2
+abby,4
+abigail,1
+abii,1
+adela,1
+adele,1
+adriana,1
+aikaterina,1
+aimee,2
+ainsley,1
+alaiyah,1
+alana,9
+alannah,2
+aleesha,1
+aleisha,2
+alessandra,2
+alessandria,1
+alessia,1
+alex,1
+alexa-rose,1
+alexandra,17
+alexia,1
+alexis,1
+alia,2
+alice,3
+alicia,5
+alisa,3
+alisha,2
+alison,1
+alissa,2
+alivia,1
+aliza,1
+allegra,1
+alysha,2
+alyssa,3
+amalia,1
+amaya,1
+amber,11
+ambrosia,1
+amelia,5
+amelie,1
+amy,15
+anari,1
+anastasia,1
+andie,1
+andrea,1
+aneka,1
+angelica,2
+angelina,1
+angie,1
+anika,1
+anita,1
+anna,1
+annabel,4
+annabella,1
+annabelle,4
+annalise,2
+anneliese,1
+annika,1
+anthea,1
+april,6
+arabella,3
+arki,1
+asha,1
+ashlee,1
+ashleigh,4
+ashley,1
+ashlie,1
+ashton,1
+aurora,1
+ava,2
+ayla,1
+bailee,3
+bailey,3
+belinda,1
+bella,2
+beth,1
+bethanie,1
+bethany,5
+bianca,5
+breana,1
+bree,1
+breeanne,1
+breony,1
+brianna,7
+bridget,4
+brielle,1
+brigette,1
+brigitte,1
+briley,1
+briony,1
+bronte,1
+brooke,11
+brooklyn,3
+brydee,1
+caitlin,16
+caitlyn,1
+callie,1
+cambell,1
+caresse,1
+carla,2
+carly,2
+carmen,1
+casey,4
+cassandra,3
+cassidy,1
+catherine,3
+channing,1
+chantelle,2
+charlee,1
+charli,1
+charlie,3
+charlize,1
+charlotte,17
+chelsea,12
+chelsie,1
+cheree,1
+chevonne,1
+cheyenne,1
+chloe,23
+christina,1
+claire,3
+claudia,3
+clodagh,1
+corie,1
+courtney,5
+crystal,1
+daniella,2
+danielle,5
+danika,1
+darcie,1
+darcy,1
+dayna,1
+delaney,1
+demie,1
+desi,1
+destynii,1
+diamond,1
+domenique,1
+eboni,1
+ebonie,1
+ebony,7
+elana,1
+eleanor,1
+eleni,1
+elise,1
+elisha,1
+eliza,7
+elizabeth,3
+ella,15
+elle,1
+ellen,3
+elli,1
+ellie,4
+ellorah,1
+ellouise,1
+elly,3
+eloise,1
+elysse,1
+emalene,1
+emerson,1
+emiily,48
+emma,16
+emmerson,1
+erin,14
+esme,1
+esther,1
+eva,2
+evangelia,1
+faith,1
+felicity,3
+finn,2
+fiona,1
+freya,2
+fyynlay,1
+gabriella,1
+gabrielle,4
+gemaley,1
+gemma,1
+genevieve,1
+georgia,19
+georgina,1
+giaan,1
+gillian,1
+giorgia,1
+giuliana,1
+grace,7
+gracie,2
+hana,1
+hanna,1
+hannah,17
+harley,1
+harriet,4
+hattie,1
+haylee,1
+hayley,7
+heather,1
+helena,1
+hollie,1
+holly,14
+imogen,9
+india,2
+indiana,2
+indyana,1
+irene,1
+isabel,1
+isabella,28
+isabelle,9
+isobel,1
+jacinta,3
+jacqueline,4
+jacynta,1
+jade,9
+jaime,2
+jaimee,1
+jamilla,1
+jaslyn,1
+jasmin,1
+jasmine,9
+jasmyn,2
+jayde,1
+jayme,1
+jazz,1
+jemima,1
+jemma,3
+jenna,4
+jennifer,1
+jessica,25
+jessie,1
+jinni,1
+joanna,1
+jordan,2
+jordyn,1
+jorja,1
+joselyn,1
+josephine,2
+julia,5
+juliana,3
+kaela,1
+kailey,2
+kaitlin,4
+kaitlyn,2
+kalli,1
+kallie,1
+karissa,1
+karla,1
+karlee,1
+karli,2
+kasey,1
+kate,3
+katelin,2
+katelyn,6
+katharine,1
+katherine,1
+kathleen,1
+katie,2
+kayla,5
+kaysey,1
+keahley,1
+keeley,2
+keelin,1
+keely,2
+keira,1
+kelsea,1
+kelsey,3
+kelsy,1
+kelsye,1
+keziah,1
+kiana,2
+kiandra,1
+kiara,2
+kiarnee,1
+kiera,2
+kierra,1
+kimberley,1
+kimberly,1
+kira,2
+kiria,1
+kirra,5
+kirrah,1
+koula,1
+kristen,2
+kristin,1
+krystin,1
+kyah,1
+kylee,3
+kylie,1
+kyra,1
+lacey,1
+laetitia,1
+laklynn,1
+lani,1
+lara,7
+larissa,2
+laura,5
+lauren,15
+layla,2
+leah,3
+lexie,1
+lia,1
+liana,1
+libby,1
+lilian,1
+lillian,1
+lillianna,1
+lilly,1
+lily,14
+livia,1
+logan,1
+louise,2
+lucinda,1
+lucy,13
+lushia,1
+lydia,1
+lynae,1
+macey,1
+mackenzi,1
+mackenzie,1
+macy,1
+madalyn,1
+maddison,4
+madeleine,6
+madeline,8
+madelyn,1
+madison,16
+maggie,1
+makayla,2
+makenzi,1
+makenzie,1
+maliah,1
+maria,1
+marianne,1
+marlee,1
+marleigh,1
+marley,1
+mary,1
+mathilde,1
+matilda,4
+matisse,2
+maya,3
+meagan,1
+meg,3
+megan,3
+meggie,1
+melanie,1
+melinda,1
+melissa,1
+mhary,1
+mia,12
+micaela,1
+michaela,3
+michelle,1
+mikaela,2
+mikayla,6
+mikhaili,1
+mikhayla,2
+mila,1
+millie,1
+miranda,1
+mollie,1
+molly,5
+monique,4
+montana,4
+montanna,1
+morgan,1
+mya,1
+mystique,1
+nacoya,1
+naomi,4
+nasyah,1
+natalee,1
+natalia,3
+natalie,1
+natasha,2
+natassia,1
+nell,1
+nellie,1
+nemesia,1
+neneh,1
+neve,1
+niamh,1
+nicola,1
+nicole,2
+nikita,2
+nikki,2
+olivia,18
+pace,1
+paige,4
+pakita,1
+paris,3
+pascale,1
+peta,1
+petreece,1
+peyton,1
+phoebe,5
+pia,1
+polly,1
+portia,1
+prudence,1
+rachael,1
+rachel,7
+raquel,1
+rebecca,4
+rebekah,2
+reegan,1
+reganne,1
+renai,1
+renee,2
+rhiannon,1
+riley,1
+roberta,1
+roisin,1
+rosa,1
+rosie,3
+ruby,14
+ryleh,1
+saara,1
+samantha,12
+samara,1
+sana,1
+sara,3
+sara-louise,1
+sarah,17
+sarsha,1
+sascha,2
+saskia,1
+savannah,1
+schkirra,1
+seanna,1
+serena,1
+shae,1
+shai,2
+shakira,1
+shakirah,1
+shana,1
+shanaye,1
+shandril,1
+shannon,1
+shantal,1
+shelbey,1
+shelby,2
+shenae,1
+shona,1
+sian,1
+sidonie,1
+sienna,3
+simone,2
+skye,1
+sonja,2
+sophie,30
+stella,1
+stephanie,10
+summer,1
+sybella,1
+sylvie,1
+taalia,1
+tabitha,1
+tahlia,4
+tahnee,1
+tahni,1
+takara,1
+takeisha,1
+talena,1
+talia,6
+taliah,3
+talissa,1
+talyah,1
+tansy,1
+tanyshah,1
+tara,10
+tarnee,1
+tarnia,1
+tarshya,1
+tayah,2
+tayla,2
+taylah,7
+taylor,3
+taylor-saige,1
+teagan,3
+teaha,1
+teal,1
+teegan,1
+tegan,1
+teileah,1
+teneille,1
+tenille,1
+teresa,1
+tess,2
+tia,1
+tiahana,1
+tiahnee,1
+tiana,3
+tiarna,3
+tiffany,1
+timara,1
+tori,1
+trinity,1
+tuscany,1
+tylah,1
+tyler,1
+vanessa,3
+vendula,1
+vianca,1
+victoria,3
+willow,1
+xani,1
+xanthe,1
+yana,1
+yasmin,3
+ysobel,1
+zali,3
+zara,2
+zarlia,1
+zoe,4

geco_data_generator/data/givenname_freq.csv

@@ -0,0 +1,888 @@
+# =============================================================================
+# givenname_freq.csv - Frequency table for given names
+#
+# Sources: - Compiled from various web sites
+#
+# Last update: 22/03/2012, Peter Christen
+# =============================================================================
+
+# =============================================================================
+# This table is in a two-column comma separated format, with the first column
+# being the names and the second a corresponding frequency count. 
+# =============================================================================
+
+aaliyah,1
+abbey,9
+abbie,2
+abby,4
+abigail,1
+abii,1
+adela,1
+adele,1
+adriana,1
+aikaterina,1
+aimee,2
+ainsley,1
+alaiyah,1
+alana,9
+alannah,2
+aleesha,1
+aleisha,2
+alessandra,2
+alessandria,1
+alessia,1
+alexa-rose,1
+alexandra,17
+alexia,1
+alexis,1
+alia,2
+alice,3
+alicia,5
+alisa,3
+alisha,2
+alison,1
+alissa,2
+alivia,1
+aliza,1
+allegra,1
+alysha,2
+alyssa,3
+amalia,1
+amaya,1
+amber,11
+ambrosia,1
+amelia,5
+amelie,1
+amy,15
+anari,1
+anastasia,1
+andie,1
+andrea,1
+aneka,1
+angelica,2
+angelina,1
+angie,1
+anika,1
+anita,1
+anna,1
+annabel,4
+annabella,1
+annabelle,4
+annalise,2
+anneliese,1
+annika,1
+anthea,1
+april,6
+arabella,3
+arki,1
+asha,1
+ashlee,1
+ashleigh,4
+#ashley,1
+ashlie,1
+#ashton,1
+aurora,1
+ava,2
+ayla,1
+bailee,3
+#bailey,3
+belinda,1
+bella,2
+beth,1
+bethanie,1
+bethany,5
+bianca,5
+breana,1
+bree,1
+breeanne,1
+breony,1
+brianna,7
+bridget,4
+brielle,1
+brigette,1
+brigitte,1
+briley,1
+briony,1
+bronte,1
+brooke,11
+brooklyn,3
+brydee,1
+caitlin,16
+caitlyn,1
+callie,1
+cambell,1
+caresse,1
+carla,2
+carly,2
+carmen,1
+#casey,4
+cassandra,3
+cassidy,1
+catherine,3
+channing,1
+chantelle,2
+charlee,1
+charli,1
+#charlie,3
+charlize,1
+charlotte,17
+chelsea,12
+chelsie,1
+cheree,1
+chevonne,1
+cheyenne,1
+chloe,23
+christina,1
+claire,3
+claudia,3
+clodagh,1
+corie,1
+courtney,5
+crystal,1
+daniella,2
+danielle,5
+danika,1
+darcie,1
+#darcy,1
+dayna,1
+delaney,1
+demie,1
+desi,1
+destynii,1
+diamond,1
+domenique,1
+eboni,1
+ebonie,1
+ebony,7
+elana,1
+eleanor,1
+eleni,1
+elise,1
+elisha,1
+eliza,7
+elizabeth,3
+ella,15
+elle,1
+ellen,3
+elli,1
+ellie,4
+ellorah,1
+ellouise,1
+elly,3
+eloise,1
+elysse,1
+emalene,1
+emerson,1
+emiily,48
+emma,16
+emmerson,1
+erin,14
+esme,1
+esther,1
+eva,2
+evangelia,1
+faith,1
+felicity,3
+#finn,2
+fiona,1
+freya,2
+fyynlay,1
+gabriella,1
+gabrielle,4
+gemaley,1
+gemma,1
+genevieve,1
+georgia,19
+georgina,1
+giaan,1
+gillian,1
+giorgia,1
+giuliana,1
+grace,7
+gracie,2
+hana,1
+hanna,1
+hannah,17
+#harley,1
+harriet,4
+hattie,1
+haylee,1
+hayley,7
+heather,1
+helena,1
+hollie,1
+holly,14
+imogen,9
+india,2
+indiana,2
+indyana,1
+irene,1
+isabel,1
+isabella,28
+isabelle,9
+isobel,1
+jacinta,3
+jacqueline,4
+jacynta,1
+jade,9
+jaime,2
+jaimee,1
+jamilla,1
+jaslyn,1
+jasmin,1
+jasmine,9
+jasmyn,2
+#jayde,1
+jayme,1
+jazz,1
+jemima,1
+jemma,3
+jenna,4
+jennifer,1
+jessica,25
+jessie,1
+jinni,1
+joanna,1
+#jordan,2
+jordyn,1
+jorja,1
+joselyn,1
+josephine,2
+julia,5
+juliana,3
+kaela,1
+kailey,2
+kaitlin,4
+kaitlyn,2
+kalli,1
+kallie,1
+karissa,1
+karla,1
+karlee,1
+karli,2
+kasey,1
+kate,3
+katelin,2
+katelyn,6
+katharine,1
+katherine,1
+kathleen,1
+katie,2
+kayla,5
+kaysey,1
+keahley,1
+keeley,2
+keelin,1
+keely,2
+keira,1
+kelsea,1
+kelsey,3
+kelsy,1
+kelsye,1
+keziah,1
+kiana,2
+kiandra,1
+kiara,2
+kiarnee,1
+kiera,2
+kierra,1
+kimberley,1
+kimberly,1
+kira,2
+kiria,1
+kirra,5
+kirrah,1
+koula,1
+kristen,2
+kristin,1
+krystin,1
+kyah,1
+kylee,3
+kylie,1
+kyra,1
+lacey,1
+laetitia,1
+laklynn,1
+lani,1
+lara,7
+larissa,2
+laura,5
+lauren,15
+layla,2
+leah,3
+lexie,1
+lia,1
+liana,1
+libby,1
+lilian,1
+lillian,1
+lillianna,1
+lilly,1
+lily,14
+livia,1
+#logan,1
+louise,2
+lucinda,1
+lucy,13
+lushia,1
+lydia,1
+lynae,1
+macey,1
+mackenzi,1
+#mackenzie,1
+macy,1
+madalyn,1
+maddison,4
+madeleine,6
+madeline,8
+madelyn,1
+madison,16
+maggie,1
+makayla,2
+makenzi,1
+makenzie,1
+maliah,1
+maria,1
+marianne,1
+marlee,1
+marleigh,1
+marley,1
+mary,1
+mathilde,1
+matilda,4
+matisse,2
+maya,3
+meagan,1
+meg,3
+megan,3
+meggie,1
+melanie,1
+melinda,1
+melissa,1
+mhary,1
+mia,12
+micaela,1
+michaela,3
+michelle,1
+mikaela,2
+mikayla,6
+mikhaili,1
+mikhayla,2
+mila,1
+millie,1
+miranda,1
+mollie,1
+molly,5
+monique,4
+montana,4
+montanna,1
+morgan,1
+mya,1
+mystique,1
+nacoya,1
+naomi,4
+nasyah,1
+natalee,1
+natalia,3
+natalie,1
+natasha,2
+natassia,1
+nell,1
+nellie,1
+nemesia,1
+neneh,1
+neve,1
+niamh,1
+nicola,1
+nicole,2
+nikita,2
+nikki,2
+olivia,18
+pace,1
+paige,4
+pakita,1
+paris,3
+pascale,1
+peta,1
+petreece,1
+peyton,1
+phoebe,5
+pia,1
+polly,1
+portia,1
+prudence,1
+rachael,1
+rachel,7
+raquel,1
+rebecca,4
+rebekah,2
+reegan,1
+reganne,1
+renai,1
+renee,2
+rhiannon,1
+#riley,1
+roberta,1
+roisin,1
+rosa,1
+rosie,3
+ruby,14
+ryleh,1
+saara,1
+samantha,12
+samara,1
+sana,1
+sara,3
+sara-louise,1
+sarah,17
+sarsha,1
+sascha,2
+saskia,1
+savannah,1
+schkirra,1
+seanna,1
+serena,1
+shae,1
+shai,2
+shakira,1
+shakirah,1
+shana,1
+shanaye,1
+shandril,1
+#shannon,1
+shantal,1
+shelbey,1
+shelby,2
+shenae,1
+shona,1
+sian,1
+sidonie,1
+sienna,3
+simone,2
+skye,1
+sonja,2
+sophie,30
+stella,1
+stephanie,10
+summer,1
+sybella,1
+sylvie,1
+taalia,1
+tabitha,1
+tahlia,4
+tahnee,1
+tahni,1
+takara,1
+takeisha,1
+talena,1
+talia,6
+taliah,3
+talissa,1
+talyah,1
+tansy,1
+tanyshah,1
+tara,10
+tarnee,1
+tarnia,1
+tarshya,1
+tayah,2
+tayla,2
+taylah,7
+taylor,3
+taylor-saige,1
+teagan,3
+teaha,1
+teal,1
+teegan,1
+tegan,1
+teileah,1
+teneille,1
+tenille,1
+teresa,1
+tess,2
+tia,1
+tiahana,1
+tiahnee,1
+tiana,3
+tiarna,3
+tiffany,1
+timara,1
+tori,1
+trinity,1
+tuscany,1
+tylah,1
+#tyler,1
+vanessa,3
+vendula,1
+vianca,1
+victoria,3
+willow,1
+xani,1
+xanthe,1
+yana,1
+yasmin,3
+ysobel,1
+zali,3
+zara,2
+zarlia,1
+zoe,4
+aaron,2
+adam,10
+adrian,1
+aidan,6
+aiden,3
+aidyn,1
+ajay,1
+alec,1
+alex,4
+alexander,15
+aloysius,1
+andrew,10
+angus,3
+anthony,3
+anton,1
+antonio,1
+archer,2
+archie,2
+arren,1
+ash,1
+ashley,1
+ashton,1
+ayden,1
+bailey,11
+bailley,1
+barkly,1
+barnaby,2
+baxter,1
+bayden,1
+bayley,2
+beau,2
+ben,2
+benedict,1
+benjamin,31
+bertie,1
+billy,1
+blade,1
+blaize,1
+blake,11
+blakeston,1
+blayke,1
+bodhi,1
+bradley,3
+braedon,3
+braiden,1
+brandon,2
+brayden,2
+brendan,1
+brett,1
+brinley,1
+brock,1
+brodee,2
+brodie,2
+brody,3
+bryce,2
+brydon,1
+byron,1
+cade,1
+cain,2
+caleb,10
+callum,7
+calvin,1
+cameron,9
+campbell,4
+carlin,2
+casey,1
+charles,4
+charlie,6
+chase,1
+christian,6
+christopher,5
+ciaran,1
+clain,1
+clement,1
+coby,2
+connor,18
+cooper,13
+corey,1
+d'arcy,1
+daen,1
+dakota,1
+dale,2
+damien,2
+daniel,21
+daniele,1
+danjel,1
+danny,1
+dante,4
+darcy,3
+david,5
+deakin,4
+deakyn,1
+dean,2
+declan,1
+declen,1
+devan,1
+dillon,2
+dimitri,1
+dominic,2
+douglas,1
+drew,1
+dylan,13
+eden,1
+edward,3
+elijah,1
+elki,1
+elton,1
+emmet,1
+ethan,19
+evan,4
+ewan,1
+fergus,2
+finlay,3
+finley,1
+finn,3
+finnbar,1
+flynn,7
+francesco,1
+fraser,2
+fynn,1
+gabriel,3
+garth,1
+george,4
+gianni,3
+grayson,1
+gregory,1
+griffin,1
+gus,1
+hamish,4
+hari,1
+harley,2
+harrison,18
+harry,14
+harvey,1
+hayden,9
+heath,2
+henry,5
+hudson,1
+hugh,2
+hugo,3
+hunter,1
+iain,1
+isaac,4
+isaiah,1
+izaac,1
+jack,35
+jackson,12
+jacob,20
+jacobie,1
+jaden,2
+jaggah,1
+jai,3
+jaiden,2
+jairus,1
+jake,14
+jakob,1
+james,28
+jamie,5
+jared,4
+jarod,1
+jarred,1
+jarrod,2
+jarryd,1
+jarvis,1
+jason,1
+jasper,5
+jassim,1
+jaxin,1
+jaxson,1
+jay,1
+jayde,1
+jayden,10
+jaykob,1
+jean-claude,1
+jed,2
+jeremiah,1
+jeremy,1
+jesse,5
+jett,2
+jock,1
+joe,2
+joel,20
+john,3
+john-paul,1
+jonah,1
+jonathon,1
+jordan,11
+jory,1
+joseph,1
+joshua,50
+judah,1
+justin,1
+jye,4
+ka,1
+kade,1
+kadin,1
+kai,3
+kale,1
+kaleb,1
+kane,6
+kayden,1
+kayne,1
+kazuki,1
+keaton,1
+keegan,1
+kenneth,1
+kieran,1
+kieren,2
+kobe,3
+koben,1
+kody,1
+konstantinos,1
+kristo,1
+ky,1
+kydan,1
+kye,2
+kyle,16
+kynan,2
+lachlan,32
+lachlan-john,1
+latham,1
+lawson,1
+lee,1
+leo,2
+leon,2
+levi,2
+lewis,5
+liam,24
+lochlan,2
+logan,3
+louis,2
+luca,1
+lucas,10
+luka,1
+lukas,2
+luke,18
+lynton,1
+mackenzie,1
+mackinley,1
+maconal,1
+macormack,1
+magnus,1
+malakai,1
+marco,1
+marcus,4
+mark,1
+marko,1
+mason,2
+matteus,1
+mattheo,1
+matthew,22
+max,7
+maxin,1
+micah,1
+michael,20
+millane,1
+miller,1
+mitchell,22
+nathan,14
+ned,3
+nicholas,25
+nicolas,1
+noah,13
+oakleigh,1
+oliver,14
+oscar,6
+owen,1
+patrick,6
+paul,1
+pearson,1
+peter,3
+philip,1
+phillip,1
+phoenix,1
+pino,1
+quinn,2
+reece,1
+reeve,1
+reuben,2
+rhett,1
+rhys,3
+richard,2
+ridley,1
+riley,17
+robbie,2
+robert,4
+robin,1
+rohan,1
+ronan,1
+rory,1
+rourke,1
+roy,1
+ruben,1
+rupert,1
+ryan,10
+ryley,1
+sachin,2
+sam,8
+samir,1
+samuel,19
+scott,2
+seamus,1
+sean,4
+sebastian,4
+seth,3
+shane,3
+shannon,1
+shaun,2
+shawn,1
+silas,2
+simon,1
+solomon,1
+spencer,1
+spyke,1
+stelio,1
+stephen,1
+steven,1
+stirling,1
+tai,1
+talan,1
+tanar,1
+tasman,1
+tate,1
+thomas,33
+timothy,11
+toby,5
+todd,1
+tom,1
+tommi-lee,1
+tommy,2
+tony,1
+travis,3
+trent,1
+trevor,1
+trey,2
+tristan,3
+troy,2
+ty,1
+tyler,5
+tynan,2
+tyron,1
+tyrone,1
+vincent,1
+wade,1
+warrick,1
+wil,1
+will,1
+william,26
+wilson,4
+xavier,3
+xepheren,1
+zac,7
+zach,1
+zachariah,2
+zachary,13
+zack,1
+zakariah,1
+zane,4
+zarran,1
+zebediah,1

geco_data_generator/data/givenname_m_freq.csv

@@ -0,0 +1,373 @@
+# =============================================================================
+# givenname_m_freq.csv - Frequency table for male given names
+#
+# Sources: - Compiled from various web sites
+#
+# Last update: 11/04/2002, Peter Christen
+# =============================================================================
+
+# =============================================================================
+# This table is in a two-column comma separated format, with the first column
+# being the names and the second a corresponding frequency count. 
+# =============================================================================
+
+aaron,2
+adam,10
+adrian,1
+aidan,6
+aiden,3
+aidyn,1
+ajay,1
+alec,1
+alex,4
+alexander,15
+aloysius,1
+andrew,10
+angus,3
+anthony,3
+anton,1
+antonio,1
+archer,2
+archie,2
+arren,1
+ash,1
+ashley,1
+ashton,1
+ayden,1
+bailey,11
+bailley,1
+barkly,1
+barnaby,2
+baxter,1
+bayden,1
+bayley,2
+beau,2
+ben,2
+benedict,1
+benjamin,31
+bertie,1
+billy,1
+blade,1
+blaize,1
+blake,11
+blakeston,1
+blayke,1
+bodhi,1
+bradley,3
+braedon,3
+braiden,1
+brandon,2
+brayden,2
+brendan,1
+brett,1
+brinley,1
+brock,1
+brodee,2
+brodie,2
+brody,3
+bryce,2
+brydon,1
+byron,1
+cade,1
+cain,2
+caleb,10
+callum,7
+calvin,1
+cameron,9
+campbell,4
+carlin,2
+casey,1
+charles,4
+charlie,6
+chase,1
+christian,6
+christopher,5
+ciaran,1
+clain,1
+clement,1
+coby,2
+connor,18
+cooper,13
+corey,1
+d'arcy,1
+daen,1
+dakota,1
+dale,2
+damien,2
+daniel,21
+daniele,1
+danjel,1
+danny,1
+dante,4
+darcy,3
+david,5
+deakin,4
+deakyn,1
+dean,2
+declan,1
+declen,1
+devan,1
+dillon,2
+dimitri,1
+dominic,2
+douglas,1
+drew,1
+dylan,13
+eden,1
+edward,3
+elijah,1
+elki,1
+elton,1
+emmet,1
+ethan,19
+evan,4
+ewan,1
+fergus,2
+finlay,3
+finley,1
+finn,3
+finnbar,1
+flynn,7
+francesco,1
+fraser,2
+fynn,1
+gabriel,3
+garth,1
+george,4
+gianni,3
+grayson,1
+gregory,1
+griffin,1
+gus,1
+hamish,4
+hari,1
+harley,2
+harrison,18
+harry,14
+harvey,1
+hayden,9
+heath,2
+henry,5
+hudson,1
+hugh,2
+hugo,3
+hunter,1
+iain,1
+isaac,4
+isaiah,1
+izaac,1
+jack,35
+jackson,12
+jacob,20
+jacobie,1
+jaden,2
+jaggah,1
+jai,3
+jaiden,2
+jairus,1
+jake,14
+jakob,1
+james,28
+jamie,5
+jared,4
+jarod,1
+jarred,1
+jarrod,2
+jarryd,1
+jarvis,1
+jason,1
+jasper,5
+jassim,1
+jaxin,1
+jaxson,1
+jay,1
+jayde,1
+jayden,10
+jaykob,1
+jean-claude,1
+jed,2
+jeremiah,1
+jeremy,1
+jesse,5
+jett,2
+jock,1
+joe,2
+joel,20
+john,3
+john-paul,1
+jonah,1
+jonathon,1
+jordan,11
+jory,1
+joseph,1
+joshua,50
+judah,1
+justin,1
+jye,4
+ka,1
+kade,1
+kadin,1
+kai,3
+kale,1
+kaleb,1
+kane,6
+kayden,1
+kayne,1
+kazuki,1
+keaton,1
+keegan,1
+kenneth,1
+kieran,1
+kieren,2
+kobe,3
+koben,1
+kody,1
+konstantinos,1
+kristo,1
+ky,1
+kydan,1
+kye,2
+kyle,16
+kynan,2
+lachlan,32
+lachlan-john,1
+latham,1
+lawson,1
+lee,1
+leo,2
+leon,2
+levi,2
+lewis,5
+liam,24
+lochlan,2
+logan,3
+louis,2
+luca,1
+lucas,10
+luka,1
+lukas,2
+luke,18
+lynton,1
+mackenzie,1
+mackinley,1
+maconal,1
+macormack,1
+magnus,1
+malakai,1
+marco,1
+marcus,4
+mark,1
+marko,1
+mason,2
+matteus,1
+mattheo,1
+matthew,22
+max,7
+maxin,1
+micah,1
+michael,20
+millane,1
+miller,1
+mitchell,22
+nathan,14
+ned,3
+nicholas,25
+nicolas,1
+noah,13
+oakleigh,1
+oliver,14
+oscar,6
+owen,1
+patrick,6
+paul,1
+pearson,1
+peter,3
+philip,1
+phillip,1
+phoenix,1
+pino,1
+quinn,2
+reece,1
+reeve,1
+reuben,2
+rhett,1
+rhys,3
+richard,2
+ridley,1
+riley,17
+robbie,2
+robert,4
+robin,1
+rohan,1
+ronan,1
+rory,1
+rourke,1
+roy,1
+ruben,1
+rupert,1
+ryan,10
+ryley,1
+sachin,2
+sam,8
+samir,1
+samuel,19
+scott,2
+seamus,1
+sean,4
+sebastian,4
+seth,3
+shane,3
+shannon,1
+shaun,2
+shawn,1
+silas,2
+simon,1
+solomon,1
+spencer,1
+spyke,1
+stelio,1
+stephen,1
+steven,1
+stirling,1
+tai,1
+talan,1
+tanar,1
+tasman,1
+tate,1
+thomas,33
+timothy,11
+toby,5
+todd,1
+tom,1
+tommi-lee,1
+tommy,2
+tony,1
+travis,3
+trent,1
+trevor,1
+trey,2
+tristan,3
+troy,2
+ty,1
+tyler,5
+tynan,2
+tyron,1
+tyrone,1
+vincent,1
+wade,1
+warrick,1
+wil,1
+will,1
+william,26
+wilson,4
+xavier,3
+xepheren,1
+zac,7
+zach,1
+zachariah,2
+zachary,13
+zack,1
+zakariah,1
+zane,4
+zarran,1
+zebediah,1

geco_data_generator/data/ocr-variations-upper-lower.csv

@@ -0,0 +1,51 @@
+# OCR character variations
+#
+5,S
+5,s
+2,Z
+2,z
+1,|
+6,G
+g,9
+q,9
+q,4
+B,8
+A,4
+0,o
+0,O
+m,n
+u,v
+U,V
+Y,V
+y,v
+D,O
+Q,O
+F,P
+E,F
+l,J
+j,i
+l,1
+g,q
+h,b
+l,I
+i,'l
+13,B
+12,R
+17,n
+iii,m
+cl,d
+w,vv
+ri,n
+k,lc
+lo,b
+IJ,U
+lJ,U
+LI,U
+I-I,H
+l>,b
+1>,b
+l<,k
+1<,k
+m,rn
+l,|
+i,:

geco_data_generator/data/ocr-variations.csv

@@ -0,0 +1,31 @@
+# OCR character variations
+#
+5,s
+2,z
+1,|
+g,9
+q,9
+q,4
+0,o
+m,n
+u,v
+y,v
+j,l
+j,i
+l,1
+h,b
+l,i
+i,'l
+iii,m
+cl,d
+w,vv
+ri,n
+k,lc
+lo,b
+l>,b
+1>,b
+l<,k
+1<,k
+m,rn
+l,|
+i,:

geco_data_generator/data/phonetic-variations.csv

@@ -0,0 +1,358 @@
+# Phonetic variation patterns, developed by Agus Pudjijono, ANU, 2008
+#
+ALL,h,@,None,None,None,None
+END,e,@,None,None,None,None
+ALL,t,d,None,None,None,None
+ALL,d,t,None,None,None,None
+ALL,c,k,None,None,None,None
+ALL,w,@,None,None,None,None
+ALL,nn,n,None,None,None,None
+ALL,ll,l,None,None,None,None
+ALL,ee,i,None,None,None,None
+ALL,z,s,None,None,None,None
+ALL,s,z,None,None,None,None
+ALL,ie,i,None,None,None,None
+END,y,i,None,None,None,None
+ALL,g,k,None,None,None,None
+ALL,th,t,None,None,None,None
+ALL,rr,r,None,None,None,None
+ALL,b,p,None,None,None,None
+ALL,j,s,None,None,None,None
+ALL,ey,y,None,None,None,None
+ALL,s,j,None,None,None,None
+ALL,tt,t,None,None,None,None
+ALL,ei,i,None,None,None,None
+ALL,ou,o,None,None,None,None
+ALL,au,o,None,None,None,None
+ALL,ck,k,None,None,None,None
+ALL,ia,ya,None,None,None,None
+ALL,j,z,None,None,None,None
+ALL,z,j,None,None,None,None
+ALL,k,ck,None,None,None,None
+ALL,ya,ia,None,None,None,None
+ALL,v,f,None,None,None,None
+ALL,f,v,None,None,None,None
+ALL,s,st,None,None,None,None
+ALL,oo,u,None,None,None,None
+ALL,ph,f,None,None,None,None
+ALL,mm,m,None,None,None,None
+ALL,ce,se,None,None,None,None
+ALL,ry,rie,None,None,None,None
+ALL,rie,ry,None,None,None,None
+ALL,ff,f,None,None,None,None
+ALL,x,@,None,None,None,None
+ALL,q,k,None,None,None,None
+END,ss,s,None,None,None,None
+MIDDLE,j,y,V,V,None,None
+ALL,sh,x,None,None,None,None
+START,ha,h,None,None,None,None
+ALL,ng,nk,None,None,None,None
+END,es,s,None,None,None,None
+ALL,pp,p,None,None,None,None
+START,ch,x,None,None,None,None
+ALL,dd,t,None,None,None,None
+ALL,nk,ng,None,None,None,None
+ALL,sch,sh,None,None,None,None
+ALL,ci,si,None,None,None,None
+ALL,aa,ar,None,None,None,None
+ALL,kk,k,None,None,None,None
+START,ho,h,None,None,None,None
+END,ee,ea,None,None,None,None
+END,sz,s,None,None,None,None
+START,ts,t,None,V,None,None
+ALL,sz,s,None,None,None,None
+ALL,cc,k,None,None,None,None
+ALL,gg,k,None,None,None,None
+START,he,h,None,None,None,None
+MIDDLE,gh,@,y;-2;b;h;d,None,None,None
+END,r,ah,V,None,None,None
+ALL,tch,ch,None,None,None,None
+START,hu,h,None,None,None,None
+MIDDLE,ch,x,None,None,None,None
+MIDDLE,z,s,None,V,None,None
+ALL,zz,s,None,None,None,None
+END,re,ar,None,None,None,None
+START,sl,s,None,None,None,None
+ALL,cia,sia,None,None,None,None
+START,oh,h,None,None,None,None
+ALL,bb,p,None,None,None,None
+ALL,sc,sk,None,None,None,None
+ALL,cy,si,None,None,None,None
+START,ah,h,None,None,None,None
+ALL,zs,s,None,None,None,None
+ALL,ca,ka,None,None,None,None
+ALL,dg,g,None,None,None,None
+ALL,yth,ith,None,None,None,None
+ALL,cy,sy,None,None,None,None
+START,kn,n,None,None,None,None
+START,sn,s,None,None,None,None
+START,hi,h,None,None,None,None
+ALL,wha,wa,None,None,None,None
+START,sm,s,None,None,None,None
+ALL,isl,il,None,None,None,None
+END,gh,e,V,None,None,None
+ALL,co,ko,None,None,None,None
+MIDDLE,gi,ji,None,None,None,None
+ALL,cio,sio,None,None,None,None
+END,ss,as,V,None,None,None
+END,gn,n,None,None,None,None
+END,gne,n,None,None,None,None
+ALL,mps,ms,None,None,None,None
+END,le,ile,C,None,None,None
+ALL,whi,wi,None,None,None,None
+ALL,tia,xia,None,None,None,None
+MIDDLE,stl,sl,V,None,None,None
+END,sch,x,None,None,None,None
+ALL,cia,xia,None,None,None,None
+ALL,jj,j,None,None,None,None
+START,cy,s,None,None,None,None
+MIDDLE,sch,x,None,None,None,None
+ALL,cie,sie,None,None,None,None
+START,cz,c,None,None,None,None
+START,eh,h,None,None,None,None
+ALL,tch,x,None,None,None,None
+ALL,mpt,mt,None,None,None,None
+ALL,cg,k,None,None,None,None
+ALL,umb,um,None,None,None,None
+ALL,gh,k,n;-1;i,None,None,None
+START,hy,h,None,None,None,None
+START,gn,n,None,None,None,None
+ALL,sce,se,None,None,None,None
+ALL,sci,si,None,None,None,None
+END,hr,ah,V,None,None,None
+END,mb,m,V,None,None,None
+ALL,lough,low,None,None,None,None
+ALL,why,wy,None,None,None,None
+ALL,ght,t,None,None,None,None
+ALL,whe,we,None,None,None,None
+ALL,rz,rsh,None,None,None,None
+START,chr,kr,None,V,None,None
+ALL,cq,k,None,None,None,None
+ALL,ghn,n,None,None,None,None
+START,x,s,None,None,None,None
+END,dl,dil,None,None,None,None
+START,mn,n,None,V,None,None
+START,pt,t,None,None,None,None
+ALL,lle,le,None,None,None,None
+ALL,qq,k,None,None,None,None
+START,chh,kh,None,None,None,None
+START,ih,h,None,None,None,None
+MIDDLE,lj,ld,V,V,None,None
+ALL,zz,ts,None,None,None,None
+MIDDLE,ach,k,None,n;1;i;e,None,None
+END,dt,t,None,None,None,None
+ALL,td,t,None,None,None,None
+END,ned,nd,None,None,None,None
+ALL,lz,lsh,None,None,None,None
+ALL,ghne,ne,None,None,None,None
+MIDDLE,z,ts,C,None,None,None
+START,cl,kl,None,V,None,None
+START,pf,f,None,None,None,None
+START,uh,h,None,None,None,None
+START,tj,ch,None,V,None,None
+START,gh,g,None,None,None,None
+MIDDLE,gy,ky,n;-1;e;i,None,n;rgy;ogy,None
+MIDDLE,r,ah,V,C,None,None
+MIDDLE,cz,ch,None,None,None,None
+ALL,cci,xi,None,None,None,None
+END,tl,til,None,None,None,None
+ALL,ough,of,None,None,None,None
+ALL,ff,v,None,None,None,None
+START,cr,kr,None,V,None,None
+START,gh,@,None,None,None,None
+ALL,cu,ku,None,None,None,None
+MIDDLE,aggi,aji,None,None,None,None
+END,ew,e,None,None,None,None
+ALL,nc,nk,None,None,None,None
+START,ps,s,None,None,None,None
+ALL,xx,@,None,None,None,None
+ALL,who,wo,None,None,None,None
+ALL,wr,r,None,None,None,None
+END,ow,o,None,None,None,None
+ALL,sholm,solm,None,None,None,None
+ALL,vv,f,None,None,None,None
+ALL,gh,f,y;-1;u|y;-3;c;g;l;r;t,None,None,None
+ALL,wh,h,None,None,None,None
+ALL,wicz,wis,None,None,None,None
+MIDDLE,q,kw,V,V,None,None
+ALL,ysl,yl,None,None,None,None
+ALL,vv,ff,None,None,None,None
+ALL,ff,vv,None,None,None,None
+START,pn,n,None,V,None,None
+START,ghi,j,None,None,None,None
+START,gin,kin,None,None,None,None
+ALL,dge,je,None,None,None,None
+ALL,whu,wu,None,None,None,None
+ALL,tion,xion,None,None,None,None
+END,gnes,ns,None,None,None,None
+START,gy,ky,None,None,None,None
+START,gie,kie,None,None,None,None
+MIDDLE,mch,mk,None,None,None,None
+ALL,jr,dr,None,None,None,None
+ALL,xc,@,None,None,None,None
+START,gey,key,None,None,None,None
+START,vanch,vank,None,None,None,None
+END,gc,k,None,None,None,None
+END,jc,k,None,None,None,None
+START,wr,r,None,None,None,None
+ALL,ct,kt,None,None,None,None
+ALL,btl,tl,None,None,None,None
+ALL,augh,arf,None,None,None,None
+START,q,kw,None,None,None,None
+MIDDLE,gn,n,None,C,None,None
+MIDDLE,wz,z,V,None,None,None
+ALL,hroug,rew,None,None,None,None
+START,yj,y,None,V,None,None
+ALL,nx,nks,None,None,None,None
+START,tsj,ch,None,V,None,None
+MIDDLE,wsk,vskie,V,None,None,None
+END,wsk,vskie,V,None,None,None
+END,stl,sl,V,None,None,None
+END,tnt,ent,None,None,None,None
+END,eaux,oh,None,None,None,None
+ALL,exci,ecs,None,None,None,None
+ALL,x,ecs,None,None,None,None
+MIDDLE,hr,ah,V,C,None,None
+END,les,iles,C,None,None,None
+ALL,mpts,mps,None,None,None,None
+MIDDLE,bacher,baker,None,None,None,None
+MIDDLE,macher,maker,None,None,None,None
+START,caesar,sesar,None,None,None,None
+ALL,chia,kia,None,None,None,None
+MIDDLE,chae,kae,None,None,None,None
+START,charac,karak,None,None,None,None
+START,charis,karis,None,None,None,None
+START,chor,kor,None,None,None,None
+START,chym,kym,None,None,None,None
+START,chia,kia,None,None,None,None
+START,chem,kem,None,None,None,None
+START,chl,kl,None,None,None,None
+START,chn,kn,None,None,None,None
+START,chm,km,None,None,None,None
+START,chb,kb,None,None,None,None
+START,chf,kf,None,None,None,None
+START,chv,kv,None,None,None,None
+START,chw,kw,None,None,None,None
+ALL,achl,akl,None,None,None,None
+ALL,ochl,okl,None,None,None,None
+ALL,uchl,ukl,None,None,None,None
+ALL,echl,ekl,None,None,None,None
+ALL,achr,akr,None,None,None,None
+ALL,ochr,okr,None,None,None,None
+ALL,uchr,ukr,None,None,None,None
+ALL,echr,ekr,None,None,None,None
+ALL,achn,akn,None,None,None,None
+ALL,ochn,okn,None,None,None,None
+ALL,uchn,ukn,None,None,None,None
+ALL,echn,ekn,None,None,None,None
+ALL,achm,akm,None,None,None,None
+ALL,ochm,okm,None,None,None,None
+ALL,uchm,ukm,None,None,None,None
+ALL,echm,ekm,None,None,None,None
+ALL,achb,akb,None,None,None,None
+ALL,ochb,okb,None,None,None,None
+ALL,uchb,ukb,None,None,None,None
+ALL,echb,ekb,None,None,None,None
+ALL,achh,akh,None,None,None,None
+ALL,ochh,okh,None,None,None,None
+ALL,uchh,ukh,None,None,None,None
+ALL,echh,ekh,None,None,None,None
+ALL,achf,akf,None,None,None,None
+ALL,ochf,okf,None,None,None,None
+ALL,uchf,ukf,None,None,None,None
+ALL,echf,ekf,None,None,None,None
+ALL,achv,akv,None,None,None,None
+ALL,ochv,okv,None,None,None,None
+ALL,uchv,ukv,None,None,None,None
+ALL,echv,ekv,None,None,None,None
+ALL,achw,akw,None,None,None,None
+ALL,ochw,okw,None,None,None,None
+ALL,uchw,ukw,None,None,None,None
+ALL,echw,ekw,None,None,None,None
+ALL,cht,kt,None,None,None,None
+ALL,chs,ks,None,None,None,None
+ALL,orches,orkes,None,None,None,None
+ALL,archit,arkit,None,None,None,None
+ALL,orchid,orkid,None,None,None,None
+START,sch,sk,None,None,None,None
+START,vonch,vonk,None,None,None,None
+ALL,acci,aksi,None,n;1;hu,None,None
+ALL,acce,akse,None,n;1;hu,None,None
+ALL,acch,aksh,None,n;1;hu,None,None
+ALL,uccee,uksee,None,None,None,None
+ALL,ucces,ukses,None,None,None,None
+ALL,cce,xi,None,None,None,None
+ALL,cch,xh,None,None,None,None
+ALL,cc,k,None,None,None,None
+ALL,cq,k,None,None,None,None
+ALL,cg,k,None,None,None,None
+ALL,dgi,ji,None,None,None,None
+ALL,dgy,jy,None,None,None,None
+ALL,dg,tk,None,None,None,None
+ALL,dt,t,None,None,None,None
+MIDDLE,gh,k,n;-1;a;i;u;e;o,None,None,None
+START,gh,k,None,None,None,None
+MIDDLE,gn,kn,y;-1;a;i;u;e;o,None,n;slavo,y;a;i;u;e;o
+MIDDLE,gney,ney,None,None,n;slavo,None
+MIDDLE,gli,kli,None,None,n;slavo,None
+START,ges,kes,None,None,None,None
+START,gep,kep,None,None,None,None
+START,geb,keb,None,None,None,None
+START,gel,kel,None,None,None,None
+START,gib,kib,None,None,None,None
+START,gil,kil,None,None,None,None
+START,gei,kei,None,None,None,None
+START,ger,ker,None,None,None,None
+MIDDLE,ger,ker,n;-1;e;i,None,n;danger;ranger;manger,None
+MIDDLE,ge,ke,None,None,None,y;van;von;sch
+MIDDLE,gi,ki,None,None,None,y;van;von;sch
+MIDDLE,aggi,aki,None,None,None,y;van;von;sch
+MIDDLE,oggi,oki,None,None,None,y;van;von;sch
+MIDDLE,oggi,oji,None,None,None,None
+MIDDLE,ge,jy,None,None,None,None
+MIDDLE,gy,jy,None,None,None,None
+MIDDLE,gier,jier,None,None,None,None
+MIDDLE,get,ket,None,None,None,None
+START,yh,h,None,None,None,None
+MIDDLE,sanjose,sanhose,None,None,None,None
+END,illo,ilo,None,None,None,None
+END,illa,ila,None,None,None,None
+END,alle,ale,None,None,None,None
+ALL,pb,p,None,None,None,None
+START,sugar,xugar,None,None,None,None
+ALL,sheim,seim,None,None,None,None
+ALL,shoek,soek,None,None,None,None
+ALL,sholz,solz,None,None,None,None
+START,sw,s,None,None,None,None
+ALL,scher,xer,None,None,None,None
+ALL,schen,xen,None,None,None,None
+ALL,schoo,skoo,None,None,None,None
+ALL,schuy,skuy,None,None,None,None
+ALL,sched,sked,None,None,None,None
+ALL,schem,skem,None,None,None,None
+START,sch,x,None,n;1;a;i;u;e;o;w,None,None
+ALL,scy,sy,None,None,None,None
+END,aiss,ai,None,None,None,None
+END,aisz,ai,None,None,None,None
+END,oiss,oi,None,None,None,None
+END,oisz,oi,None,None,None,None
+ALL,tth,t,None,None,None,None
+END,aw,a,None,None,None,None
+END,iw,i,None,None,None,None
+END,uw,u,None,None,None,None
+END,yw,y,None,None,None,None
+ALL,witz,ts,None,None,None,None
+ALL,wicz,ts,None,None,None,None
+END,iaux,iauks,None,None,None,None
+END,eaux,eauks,None,None,None,None
+END,aux,auks,None,None,None,None
+END,oux,ouks,None,None,None,None
+ALL,zh,jh,None,None,None,None
+END,i,y,None,None,None,None
+ALL,zzo,so,None,None,None,None
+ALL,zzi,si,None,None,None,None
+ALL,zza,sa,None,None,None,None
+MIDDLE,z,s,n;-1;t,None,y;slavo,None
+MIDDLE,ks,x,None,None,None,None
+MIDDLE,cks,x,y;-1;a;i;u;e;o,None,None,None
+END,l,le,y;-1;ai,None,None,None

geco_data_generator/data/postcode_act_freq.csv

@@ -0,0 +1,43 @@
+# =============================================================================
+# postcode_act_freq.csv - Frequency table for postcodes in the ACT
+#
+# Based on 'Australia on Disk' data files (2002)
+#
+# Last update: 31/03/2005, Peter Christen
+# =============================================================================
+
+# =============================================================================
+# This table is in a two-column comma separated format, with the first column
+# being the names and the second a corresponding frequency count. 
+# =============================================================================
+
+2582,4
+2586,24
+2600,2912
+2601,546
+2602,10842
+2603,3455
+2604,3359
+2605,4581
+2606,3416
+2607,5504
+2608,4
+2609,287
+2611,9273
+2612,4157
+2614,7762
+2615,13417
+2617,8737
+2618,457
+2620,273
+2621,98
+2900,424
+2902,5781
+2903,3472
+2904,4525
+2905,9313
+2906,4848
+2911,34
+2912,65
+2913,6823
+2914,1164

geco_data_generator/data/qwerty-keyboard.csv

@@ -0,0 +1,9 @@
+# QWERTY keyboad layout
+#
+q,w,e,r,t,y,u,i,o,p
+a,s,d,f,g,h,j,k,l
+z,x,c,v,b,n,m
+#
+7,8,9
+4,5,6
+1,2,3

geco_data_generator/data/state-income.csv

@@ -0,0 +1,11 @@
+# Look-up file for generating a compound attribute: state / income. For details
+# see module generator.py, class GenerateCateContCompoundAttribute
+#
+act,7,uniform,20000,200000
+nsw,25,uniform,25000,500000
+vic,21,normal,45000,10000,15000,None
+qld,14,uniform,20000,100000
+nt,3,uniform,20000,100000
+tas,8,normal,25000,20000,10000,None
+sa,12,uniform,25000,250000
+wa,10,normal,65000,60000,20000,None

geco_data_generator/data/surname-freq-japanese.csv

@@ -0,0 +1,22 @@
+����,5
+�–�,30
+��o,110
+�ɏW�@,5
+�ɓ�,2000
+���c,281
+����,872
+����,390
+�ē�,901
+����,5016
+���R,90
+���,2098
+�c��,2592
+���L,421
+�y�c,120
+�L�c,208
+���{,872
+�X�c,398
+�R�{,1104
+�{�c,383
+�g�c,981
+�n��,123

geco_data_generator/data/surname-misspell-japanese.csv

@@ -0,0 +1,14 @@
+����,����
+��o,���
+�ɓ�,�ɓ�
+�ē�,�V��
+�ē�,�֓�
+���c,��c
+����,�Z��
+���R,��R
+���L,���A
+���L,���L
+���L,���A
+�L�c,�A�c
+�n��,�n�
+�n��,�n�

geco_data_generator/data/surname-misspell.csv

@@ -0,0 +1,443 @@
+# =============================================================================
+# surname-misspell.csv - Lookup-table for surname misspellings used for the
+#                        database generator
+#
+# - The word left of the comma is the correct spelling, right of the comma is
+#   the corresponding misspelling
+# - Several misspellings can be given fir the same correct spelling
+#
+# Last update: 18/03/2012, Peter Christen
+# =============================================================================
+
+aitchison,acheson
+aitken,aiken
+aldis,aldous
+almond,allmond
+althea,thea
+arden,ardie
+arland,arley
+arland,arlie
+arland,arly
+armen,armand
+arnoud,arnout
+avice,avis
+avice,awis
+
+barclay,berkeley
+baxter,bax
+blythe,blithe
+boleslaw,bolestlaw
+bowden,bowen
+boyle,oboyle
+bree,obree
+brice,bryce
+brian,brien
+brian,briant
+brian,bryan
+brian,bryant
+brian,obrian
+brian,obrien
+brian,obryan
+brinley,brindley
+bruckner,brukner
+burl,burlie
+burrows,burroughs
+bush,busch
+byers,byas
+byers,byass
+byrne,byrnes
+
+cain,caine
+cain,cane
+cain,conn
+cain,kain
+cain,kahn
+cain,kon
+cain,okane
+cain,okeane
+callaghan,callahan
+callaghan,ocallaghan
+calvert,calvat
+campbell,cambell
+car,kaare
+carlisle,carlile
+carlisle,carlyle
+castle,cassel
+castle,cassell
+castle,kassel
+chapman,chap
+cletus,clete
+cleveland,cleave
+cleveland,cleve
+clyne,klein
+coldbeck,colbeck
+coleman,colman
+concepcion,conchita
+connell,oconnell
+connor,conner
+connor,oconner
+connor,oconnor
+corbett,corby
+cosh,koch
+cramer,kramer
+cramer,kraymer
+cramer,kremer
+creighton,crichton
+crowe,krogh
+cruise,crews
+cruise,kruse
+cummins,cummings
+cyrus,cy
+
+davidson,davison
+davidson,davissen
+davina,davida
+dea,odea
+dell,odell
+denbeigh,denby
+denholm,denham
+dennis,dennys
+desmond,desmon
+dickson,dixon
+dinh,din
+dinh,dingh
+dinning,dinnin
+doherty,docherty
+doherty,dougherty
+doherty,odoherty
+dolman,dollman
+donaghue,odonaghue
+donaghue,odonahoo
+donaghue,odonahue
+donnell,odonnell
+donohoe,donoghue
+donovan,odonovan
+dowd,odowd
+driscoll,odriscill
+driscoll,odriscoll
+dudley,dud
+dudley,dudleigh
+duff,duffy
+duke,dukes
+dwyer,odwyer
+
+eames,ames
+eames,amies
+elder,elde
+elms,elemes
+engle,engel
+engle,ingle
+english,inglish
+english,ingliss
+eyres,ayers
+eyres,ayres
+ezekiel,zech
+ezekiel,zeke
+
+farrell,ofarrell
+faulkner,falc
+faulkner,falcon
+faulkner,falconer
+faulkner,falk
+faulkner,falkiner
+faulkner,fawkner
+finlay,findlay
+finlay,findley
+fitzner,pfitzner
+flaherty,oflaherty
+flanagan,oflanagan
+flynn,oflynn
+ford,forde
+forster,foster
+freeman,freedman
+french,ffrench
+frost,ffrost
+
+gallagher,ogallagher
+gara,ogara
+gaven,gavin
+geraghty,garretty
+geraghty,garrety
+geraghty,garrity
+gillman,gilman
+gordon,gordie
+gordon,gordy
+gorman,ogorman
+gough,goff
+gower,ogower
+grady,ogrady
+
+hadleigh,hadley
+hagan,ohagan
+hallor,ohallor
+halloran,ohalloran
+han,ohan
+hanaffian,ohanaffian
+hancock,handcock
+hanes,ohanes
+hanessian,ohanessian
+hanian,ohanian
+hanley,hambley
+hanley,hamley
+hanley,handley
+hanlon,ohanlon
+hannes,ohannes
+hannessian,ohannessian
+har,ohar
+hara,ohara
+hara,oharae
+hare,ohaiher
+hare,ohaire
+hare,ohare
+hare,ohegir
+hare,ohehar
+hare,ohehier
+hare,ohehir
+hare,oheir
+harford,hartford
+harris,oharris
+hart,ohart
+hawkyard,halkyard
+hayon,ohayon
+hayward,haywood
+hayward,heyward
+hayward,heywood
+hayward,howard
+hazy,ohazy
+hea,ohea
+hearn,ohearn
+hodgson,hodson
+horton,hawtin
+horton,houghton
+hough,hoff
+hudson,housten
+hudson,houston
+hudson,huston
+hughes,hewes
+humphrey,humfrey
+humphrey,onofredo
+
+irving,ervy
+irving,irvin
+irving,irvine
+islay,isles
+
+johnson,johnston
+johnson,johnstone
+junior,jnr
+juris,yuris
+
+kantor,cantor
+karlsen,carlson
+kavanagh,cavanagh
+kavanagh,cavanough
+kavanagh,cavenagh
+kealley,keighley
+kearney,carney
+kearney,carnie
+kearney,okearney
+keefe,okeefe
+keese,okeese
+keil,okeil
+keith,okeith
+kel,okel
+kennely,kennerley
+kenneth,ken
+kenneth,keneth
+kenneth,kenethe
+kenneth,kenith
+kenneth,kennith
+kenneth,kenny
+kirby,kirkby
+klap,clap
+klap,clapp
+kohen,coen
+kohen,cohen
+kohen,cohn
+koster,costa
+koster,coster
+
+laco,olaco
+langford,langsford
+laslo,laszlo
+laughton,lawton
+leach,leitch
+leary,oleary
+lennox,leannox
+lisle,lyal
+lisle,lydall
+lisle,lyle
+lloyd,floyd
+loan,oloan
+lachlan,loughlin
+lachlan,olachlan
+lachlan,olaughlan
+lachlan,ologhlin
+lachlan,oloughlan
+lynam,olynam
+lyndon,lindon
+
+mace,maze
+maddock,maddocks
+maher,maier
+maher,mayar
+maher,meagher
+maher,omeagher
+mahon,mann
+mahony,mahoney
+mahony,omahoney
+mahony,omahony
+mai,may
+malley,omalley
+malley,omally
+malley,omeley
+mara,omara
+mara,omeara
+mara,omera
+marsh,march
+massey,massie
+matheson,matherson
+mavis,mab
+mervyn,merv
+mervyn,mervin
+meyer,myer
+miles,myles
+millicent,mildred
+millie,milli
+millie,milly
+mitchell,michaal
+mitchell,michaele
+mitchell,michaell
+mitchell,micheal
+mitchell,michell
+mitchell,mick
+mitchell,micky
+mitchell,mikcos
+mitchell,mike
+mitchell,mitch
+montague,monty
+mosley,morsley
+mullane,omullane
+
+nada,nadine
+nains,onains
+nevern,nevin
+newbury,newby
+norton,naughton
+norton,naunton
+nosworthy,norsworthy
+
+ogden,oddie
+ogden,oddy
+
+panagiotis,panayotis
+patterson,pattison
+pearce,pearse
+powers,powys
+prendergast,pendergast
+price,preiss
+pritchard,prichard
+
+quinton,quentin
+
+raleigh,rawleigh
+raleigh,rawley
+raleigh,rowley
+redman,redmond
+reece,rees
+regan,oregan
+reilly,oreilly
+reilly,orielly
+reuben,rube
+reuben,ruben
+reynard,reyner
+reynolds,reynol
+reynolds,reynold
+roach,roache
+roach,roatch
+roach,roche
+robertson,roberson
+robertson,robieson
+robertson,robinson
+roer,ruggiero
+rogers,rodgers
+rourke,orourke
+ruthen,ruthven
+
+sampson,samson
+sanderson,sandison
+sandford,sanford
+schultz,scholz
+schultz,schulz
+schultz,schulze
+schultz,shultz
+schultz,shultze
+schwartz,schwarz
+seaton,seton
+shana,oshana
+shana,oshanna
+shannessy,oshanassy
+shannessy,oshanesy
+shannessy,oshannessy
+shannessy,oshaughnessy
+shea,oshae
+shea,oshea
+sheehy,osheehy
+sheils,shields
+sheils,shiels
+shell,schell
+simmons,simmins
+simmons,simmonds
+simmons,simons
+simmons,symanns
+simmons,symonds
+slavomir,slawomir
+solomon,sol
+solomon,saul
+spiro,spiros
+staughton,staunton
+stbaker,saintbaker
+stclair,saintclair
+stclair,saintclaire
+stclair,saintclare
+stclair,stclaire
+stclair,stclare
+stcloud,saintcloud
+stdenis,saintdenis
+stdenis,saintdennis
+stdenis,stdennis
+stephens,stevens
+stgeorge,saintgeorge
+stjack,saintjack
+stjohn,saintjohn
+stjohnwood,saintjohnwood
+stjulian,saintjulian
+stlaurence,saintlaurence
+stleon,saintleon
+sullivan,osullivan
+
+thompson,thomsen
+thompson,thomson
+toole,otoole
+
+vaughn,vaughan
+
+warner,warnie
+weiner,wiener
+weiner,wierner
+weston,western
+white,wight
+whiteman,whitmann
+whiteman,wightman
+whitman,whit
+wilmot,willmott
+wiltshire,willshire
+windsor,winsor
+
+young,oyoung
+
+zadie,zaidie
+zbigneif,zbignev
+zbigneif,zbignief
+zbigneif,zbigniew
+zdislaw,zdzislaw

geco_data_generator/generator.py

@@ -0,0 +1,2067 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Main classes to generate records and the data set
+import random
+
+from geco_data_generator import basefunctions
+
+
+# =============================================================================
+# Classes for generating a single attribute (field) of the data set
+# =============================================================================
+
+
+class GenerateAttribute:
+    """Base class for the definition of a single attribute (field) to be
+    generated.
+
+    This class and all of its derived classes provide methods that allow the
+    definition of a single attribute and the parameters necessary for its
+    generation.
+
+    The following variables need to be set when a GenerateAttribute instance
+    is initialised (with further parameters listed in the derived classes):
+
+    attribute_name  The name of this attribute, which will be used in the
+                    header line to be written into the output file.
+
+                    Ideally, this attribute name should be short, not contain
+                    spaces and it must not contain any quote or punctuation
+                    characters.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, base_kwargs):
+        """Constructor, set general attributes."""
+
+        # General attributes for all attribute generators
+        #
+        self.attribute_name = None
+
+        # Process the keyword argument (all keywords specific to a certain data
+        # generator type were processed in the derived class constructor)
+        #
+        for (keyword, value) in base_kwargs.items():
+
+            if keyword.startswith('attribute'):
+                basefunctions.check_is_non_empty_string('attribute_name', value)
+                self.attribute_name = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        basefunctions.check_is_non_empty_string('attribute_name', self.attribute_name)
+
+        # Check the content of the attribute name string for certain characters
+        # that would pose problems when generating comma separated values (CSV)
+        # files.
+        #
+        if (
+            ("'" in self.attribute_name)
+            or ('"' in self.attribute_name)
+            or ("`" in self.attribute_name)
+            or (',' in self.attribute_name)
+            or (";" in self.attribute_name)
+            or ('\t' in self.attribute_name)
+        ):
+            raise Exception(
+                'Illegal character (such as comma, semi-colon or'
+                + 'quote in attribute name'
+            )
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_value(self):
+        """Method which creates and returns one attribute value.
+        See implementations in derived classes for details.
+        """
+
+        raise Exception('Override abstract method in derived class')
+
+
+# =============================================================================
+
+
+class GenerateFreqAttribute(GenerateAttribute):
+    """Generate an attribute where values are retrieved from a lookup table that
+    contains categorical attribute values and their frequencies.
+
+    The additional argument (besides the base class argument 'attribute_name')
+    that has to be set when this attribute type is initialised are:
+
+    freq_file_name    The name of the file which contains the attribute values
+                      and their frequencies.
+
+                      This file must be in comma separated values (CSV) format
+                      with the first column being the attribute values and the
+                      second column their counts (positive integer numbers).
+
+                      Each attribute value must only occur once in the
+                      frequency file.
+
+    has_header_line   A flag, set to True or False, that has to be set
+                      according to if the frequency file starts with a header
+                      line or not.
+
+    unicode_encoding  The Unicode encoding (a string name) of the file.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.attribute_type = 'Frequency'
+        self.freq_file_name = None
+        self.has_header_line = None
+        self.unicode_encoding = None
+        self.attr_value_list = []  # The list of attribute values to be loaded
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('freq'):
+                basefunctions.check_is_non_empty_string('freq_file_name', value)
+                self.freq_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        GenerateAttribute.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string('freq_file_name', self.freq_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        # Load the frequency file - - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, freq_file_data = basefunctions.read_csv_file(
+            self.freq_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        val_dict = {}  # The attribute values to be loaded from file and their
+        # counts or frequencies
+
+        # Process values from file and their frequencies
+        #
+        for line, rec_list in enumerate(freq_file_data):
+            if len(rec_list) != 2:
+                raise Exception(
+                    'Illegal format in frequency file %s: %s' % (self.freq_file_name, line)
+                )
+            line_val = rec_list[0].strip()
+            try:
+                line_count = int(rec_list[1])
+            except:
+                raise Exception(
+                    'Value count given is not an integer number: %s' % (rec_list[1])
+                )
+
+            if line_val == '':
+                raise Exception(
+                    'Empty attribute value in frequency file %s' % (self.freq_file_name)
+                )
+            basefunctions.check_is_positive('line_count', line_count)
+
+            if line_val in val_dict:
+                raise Exception(
+                    'Attribute values "%s" occurs twice in ' % (line_val)
+                    + 'frequency file %s' % (self.freq_file_name)
+                )
+
+            val_dict[line_val] = line_count
+
+        val_list = []  # The list of attribute values, with values repeated
+        # according to their frequencies
+
+        # Generate a list of values according to their counts
+        #
+        for (attr_val, val_count) in val_dict.items():
+
+            # Append value as many times as given in their counts
+            #
+            new_list = [attr_val] * val_count
+            val_list += new_list
+
+        random.shuffle(val_list)  # Randomly shuffle the list of values
+
+        self.attr_value_list = val_list
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_value(self):
+        """Method which creates and returns one attribute value randomly selected
+        from the attribute value lookup table.
+        """
+
+        assert self.attr_value_list != []
+
+        return random.choice(self.attr_value_list)
+
+
+# =============================================================================
+
+
+class GenerateFuncAttribute(GenerateAttribute):
+    """Generate an attribute where values are retrieved from a function that
+    creates values according to some specification.
+
+    Such functions include creating telephone numbers or social security
+    numbers with a certain structure, or numerical values normally or
+    uniformly distributed according to some parameter setting.
+
+    The additional argument (besides the base class argument 'attribute_name')
+    that has to be set when this attribute type is initialised are:
+
+    function    A Python function that, when called, has to return a string
+                value that is created according to some specification.
+
+    parameters  A list of one or more parameters (maximum 5) passed to the
+                function when it is called.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        self.attribute_type = 'Function'
+        self.function = None
+        self.parameters = None
+
+        # Process all keyword arguments
+        #
+        base_kwargs = {}  # Dictionary, will contain unprocessed arguments
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('funct'):
+                basefunctions.check_is_function_or_method('function', value)
+                self.function = value
+
+            elif keyword.startswith('para'):
+                basefunctions.check_is_list('parameters', value)
+                if len(value) > 5:
+                    raise Exception('Maximum five parameters allowed for function call')
+                self.parameters = value
+
+            else:
+                base_kwargs[keyword] = value
+
+        GenerateAttribute.__init__(self, base_kwargs)  # Process base arguments
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_function_or_method('function', self.function)
+
+        # Check if the function does return a string (five different possibilities,
+        # depending upon number of parameters)
+        #
+        if (self.parameters == None) or (len(self.parameters) == 0):
+            funct_ret = self.function()
+        elif len(self.parameters) == 1:
+            funct_ret = self.function(self.parameters[0])
+        elif len(self.parameters) == 2:
+            funct_ret = self.function(self.parameters[0], self.parameters[1])
+        elif len(self.parameters) == 3:
+            funct_ret = self.function(
+                self.parameters[0], self.parameters[1], self.parameters[2]
+            )
+        elif len(self.parameters) == 4:
+            funct_ret = self.function(
+                self.parameters[0],
+                self.parameters[1],
+                self.parameters[2],
+                self.parameters[3],
+            )
+        else:
+            funct_ret = self.function(
+                self.parameters[0],
+                self.parameters[1],
+                self.parameters[2],
+                self.parameters[3],
+                self.parameters[4],
+            )
+
+        if not isinstance(funct_ret, str):
+            raise Exception(
+                (
+                    'Function provided does not return a string value:',
+                    self.function,
+                    type(funct_ret),
+                )
+            )
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_value(self):
+        """Method which creates and returns one attribute value generated by the
+        function provided.
+        """
+
+        if self.parameters == None:
+            funct_ret = self.function()
+        elif len(self.parameters) == 1:
+            funct_ret = self.function(self.parameters[0])
+        elif len(self.parameters) == 2:
+            funct_ret = self.function(self.parameters[0], self.parameters[1])
+        elif len(self.parameters) == 3:
+            funct_ret = self.function(
+                self.parameters[0], self.parameters[1], self.parameters[2]
+            )
+        elif len(self.parameters) == 4:
+            funct_ret = self.function(
+                self.parameters[0],
+                self.parameters[1],
+                self.parameters[2],
+                self.parameters[3],
+            )
+        else:
+            funct_ret = self.function(
+                self.parameters[0],
+                self.parameters[1],
+                self.parameters[2],
+                self.parameters[3],
+                self.parameters[4],
+            )
+        return funct_ret
+
+
+# =============================================================================
+# Classes for generating compound attributes (fields) of the data set
+# =============================================================================
+
+
+class GenerateCompoundAttribute:
+    """Base class for the definition of compound attributes (fields) to be
+    generated.
+
+    This class and all of its derived classes provide methods that allow the
+    definition of several (are least two) attributes and the parameters
+    necessary for their generation.
+
+    This base class does not have any generic variables that need to be set.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, base_kwargs):
+        """Constructor. See implementations in derived classes for details."""
+
+        raise Exception('Override abstract method in derived class')
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_value(self):
+        """Method which creates and returns several (compound) attribute values.
+        See implementations in derived classes for details.
+        """
+
+        raise Exception('Override abstract method in derived class')
+
+
+# =============================================================================
+
+
+class GenerateCateCateCompoundAttribute(GenerateCompoundAttribute):
+    """Generate two attributes, both containing categorical values, where the
+     values of the second attribute depend upon the values in the first
+     attribute.
+
+     This for example allows the modelling of:
+     - city location values that depend upon gender values, or
+     - medication name values that depend upon gender values.
+
+     The arguments that have to be set when this attribute type is initialised
+     are:
+
+     categorical1_attribute_name  The name of the first categorical attribute
+                                  that will be generated. This name will be
+                                  used in the header line to be written into
+                                  the output file.
+
+     categorical2_attribute_name  The name of the second categorical attribute
+                                  that will be generated. This name will be
+                                  used in the header line to be written into
+                                  the output file.
+
+     lookup_file_name             Name of the file which contains the values of
+                                  the first categorical attribute, and for each
+                                  of these values the names of the categories
+                                  and their counts of the second categorical
+                                  attribute. This file format is further
+                                  explained below.
+
+     has_header_line              A flag, set to True or False, that has to be
+                                  set according to if the look-up file starts
+                                  with a header line or not.
+
+     unicode_encoding             The Unicode encoding (a string name) of the
+                                  file.
+
+     The format of the look-up file is:
+
+     # Comment lines start with the # character
+     cate_attr1_val,count,cate_attr2_val1,count1,cate_attr2_val2,count2, \
+     cate_attr2_val3,count3,cate_attr2_val4,count4, ...
+
+     The look-up file is a comma separated values (CSV) file which contains
+     two types of rows:
+     A) The first type of row contains the following columns:
+        1) A categorical value. For all possible values of the first
+           categorical attribute, one row must be specified in this look-up
+           file.
+        2) Count of this categorical value (a positive integer number). This
+           determines the likelihood of how often a certain categorical value
+           will be chosen. This count must be a positive integer number.
+        3) The first categorical value of the second attribute.
+        4) The count (positive integer number) of this first categorical
+           value.
+        5) The second categorical value of the second attribute.
+        6) The count of this second categorical value.
+
+        ...
+
+        X) A '\' character, which indicates that the following line (row)
+           contains further categorical values and their counts from the
+           second attribute.
+
+     B) The second type of row contains the following columns:
+        1) A categorical value of the second attribute.
+        2) The count of this categorical value.
+        3) Another categorical value of the second attribute.
+        4) The count of this categorical value.
+
+        ...
+
+     Example:
+       male,60,canberra,7, \
+       sydney,30,melbourne,45, \
+       perth,18
+       female,40,canberra,10,sydney,40, \
+       melbourne,20,brisbane,30,hobart,5,\
+       perth,20
+  """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        # General attributes for all data set generators
+        #
+        self.number_of_atttributes = 2
+        self.attribute_type = 'Compound-Categorical-Categorical'
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('categorical1'):
+                basefunctions.check_is_non_empty_string(
+                    'categorical1_attribute_name', value
+                )
+                self.categorical1_attribute_name = value
+
+            elif keyword.startswith('categorical2'):
+                basefunctions.check_is_non_empty_string(
+                    'categorical2_attribute_name', value
+                )
+                self.categorical2_attribute_name = value
+
+            elif keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                raise (
+                    Exception,
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword)),
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string(
+            'categorical1_attribute_name', self.categorical1_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'categorical2_attribute_name', self.categorical2_attribute_name
+        )
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        if self.categorical1_attribute_name == self.categorical2_attribute_name:
+            raise Exception('Both attribute names are the same')
+
+        # Load the lookup file - - - - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        cate_val1_dict = {}  # The categorical values from attribute 1 to be loaded
+        # from file and their counts.
+
+        cate_val2_dict = {}  # The categorical values from attribute 1 to be loaded
+        # as keys and lists of categorical values (according
+        # to their counts) from attribute 2 as values.
+
+        # Process attribute values from file and their details
+        #
+        i = 0  # Line counter in file data
+
+        while i < len(lookup_file_data):
+            rec_list = lookup_file_data[i]
+
+            # First line must contain categorical value of the first attribute
+            #
+            if len(rec_list) < 2:  # Need at least two values in each line
+                raise Exception(
+                    'Illegal format in lookup file %s: %s'
+                    % (self.freq_file_name, str(rec_list))
+                )
+            cate_attr1_val = rec_list[0].strip()
+            try:
+                cate_attr1_count = int(rec_list[1])
+            except:
+                raise Exception(
+                    'Value count given for attribute 1 is not an '
+                    + 'integer number: %s' % (rec_list[1])
+                )
+
+            if cate_attr1_val == '':
+                raise Exception(
+                    'Empty categorical attribute 1 value in lookup '
+                    + 'file %s' % (self.lookup_file_name)
+                )
+            basefunctions.check_is_positive('cate_attr1_count', cate_attr1_count)
+
+            if cate_attr1_val in cate_val1_dict:
+                raise Exception(
+                    'Attribute 1 value "%s" occurs twice in ' % (cate_attr1_val)
+                    + 'lookup file %s' % (self.lookup_file_name)
+                )
+
+            cate_val1_dict[cate_attr1_val] = cate_attr1_count
+
+            # Process values for second categorical attribute in this line
+            #
+            cate_attr2_data = rec_list[2:]  # All values and counts of attribute 2
+
+            this_cate_val2_dict = {}  # Values in second categorical attribute for
+            # this categorical value from first attribute
+
+            while cate_attr2_data != []:
+                if len(cate_attr2_data) == 1:
+                    if cate_attr2_data[0] != '\\':
+                        raise Exception(
+                            'Line in categorical look-up file has illegal' + 'format.'
+                        )
+                    # Get the next record from file data with a continuation of the
+                    # categorical values from the second attribute
+                    #
+                    i += 1
+                    cate_attr2_data = lookup_file_data[i]
+                    if len(cate_attr2_data) < 2:
+                        raise Exception(
+                            'Illegal format in lookup file %s: %s'
+                            % (self.freq_file_name, str(cate_attr2_data))
+                        )
+
+                cate_attr2_val = cate_attr2_data[0]
+                try:
+                    cate_attr2_count = int(cate_attr2_data[1])
+                except:
+                    raise Exception(
+                        'Value count given for attribute 2 is not an '
+                        + 'integer number: %s' % (cate_attr2_data[1])
+                    )
+
+                if cate_attr2_val == '':
+                    raise Exception(
+                        'Empty categorical attribute 2 value in lookup'
+                        + ' file %s' % (self.lookup_file_name)
+                    )
+                basefunctions.check_is_positive('cate_attr2_count', cate_attr2_count)
+
+                if cate_attr2_val in cate_val2_dict:
+                    raise Exception(
+                        'Attribute 2 value "%s" occurs twice in ' % (cate_attr2_val)
+                        + 'lookup file %s' % (self.lookup_file_name)
+                    )
+
+                this_cate_val2_dict[cate_attr2_val] = cate_attr2_count
+
+                cate_attr2_data = cate_attr2_data[2:]
+
+            # Generate a list of values according to their counts
+            #
+            cate_attr2_val_list = []
+
+            for (cate_attr2_val, val2_count) in this_cate_val2_dict.items():
+
+                # Append value as many times as given in their counts
+                #
+                new_list = [cate_attr2_val] * val2_count
+                cate_attr2_val_list += new_list
+
+            random.shuffle(cate_attr2_val_list)  # Randomly shuffle the list of values
+
+            cate_val2_dict[cate_attr1_val] = cate_attr2_val_list
+
+            # Go to next line in file data
+            #
+            i += 1
+
+        # Generate a list of values according to their counts
+        #
+        cate_attr1_val_list = []
+
+        for (cate_attr1_val, val1_count) in cate_val1_dict.items():
+
+            # Append value as many times as given in their counts
+            #
+            new_list = [cate_attr1_val] * val1_count
+            cate_attr1_val_list += new_list
+
+        random.shuffle(cate_attr1_val_list)  # Randomly shuffle the list of values
+
+        self.cate_attr1_val_list = cate_attr1_val_list
+        self.cate_val2_dict = cate_val2_dict
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_values(self):
+        """Method which creates and returns two categorical attribute values, where
+        the second value depends upon the first value. Both categorical values
+        are randomly selected according to the provided frequency distributions.
+        """
+
+        assert self.cate_attr1_val_list != []
+        assert self.cate_val2_dict != {}
+
+        cate_attr1_val = random.choice(self.cate_attr1_val_list)
+
+        cate_attr2_list = self.cate_val2_dict[cate_attr1_val]
+
+        cate_attr2_val = random.choice(cate_attr2_list)
+
+        return cate_attr1_val, cate_attr2_val
+
+
+# =============================================================================
+
+
+class GenerateCateContCompoundAttribute(GenerateCompoundAttribute):
+    """Generate two attributes, one containing categorical values and the other
+    continuous values, where the continuous values depend upon the categorical
+    values.
+
+    This for example allows the modelling of:
+    - salary values that depend upon gender values, or
+    - blood pressure values that depend upon age values.
+
+    The arguments that have to be set when this attribute type is initialised
+    are:
+
+    categorical_attribute_name  The name of the categorical attribute that
+                                will be generated. This name will be used in
+                                the header line to be written into the output
+                                file.
+
+    continuous_attribute_name   The name of the continuous attribute that will
+                                be generated. This name will be used in the
+                                header line to be written into the output
+                                file.
+
+    lookup_file_name            Name of the file which contains the values of
+                                the continuous attribute, and for each of these
+                                values the name of a function (and its
+                                parameters) that is used to generate the
+                                continuous values. This file format is further
+                                explained below.
+
+    has_header_line             A flag, set to True or False, that has to be
+                                set according to if the look-up file starts
+                                with a header line or not.
+
+    unicode_encoding            The Unicode encoding (a string name) of the
+                                file.
+
+    continuous_value_type       The format of how continuous values are
+                                returned when they are generated. Possible
+                                values are 'int', so integer values are
+                                returned; or 'float1', 'float2', to 'float9',
+                                in which case floating-point values with the
+                                specified number of digits behind the comma
+                                are returned.
+
+    The format of the look-up file is:
+
+    # Comment lines start with the # character
+    cate_val,count,funct_name,funct_param_1,...,funct_param_N
+
+    The look-up file is a comma separated values (CSV) file with the following
+    columns:
+    1) A categorical value. For all possible categorical values of an
+       attribute, one row must be specified in this look-up file.
+
+    2) Count of this categorical value (a positive integer number). This
+       determines the likelihood of how often a certain categorical value will
+       be chosen.
+
+    3) A function which generates the continuous value for this categorical
+       value. Implemented functions currently are:
+       - uniform
+       - normal
+
+    4) The parameters required for the function that generates the continuous
+       values. They are:
+       - uniform:  min_val, max_val
+       - normal:   mu, sigma, min_val, max_val
+                   (min_val and max_val can be set to None in which case no
+                   minimum or maximum is enforced)
+
+    Example:
+      male,60,uniform,20000,100000
+      female,40,normal,35000,100000,10000,None
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        # General attributes for all data set generators
+        #
+        self.number_of_atttributes = 2
+        self.attribute_type = 'Compound-Categorical-Continuous'
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('cate'):
+                basefunctions.check_is_non_empty_string(
+                    'categorical_attribute_name', value
+                )
+                self.categorical_attribute_name = value
+
+            elif keyword.startswith('continuous_a'):
+                basefunctions.check_is_non_empty_string('continuous_attribute_name', value)
+                self.continuous_attribute_name = value
+
+            elif keyword.startswith('continuous_v'):
+                basefunctions.check_is_non_empty_string('continuous_value_type', value)
+                basefunctions.check_is_valid_format_str('continuous_value_type', value)
+                self.continuous_value_type = value
+
+            elif keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string(
+            'categorical_attribute_name', self.categorical_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous_attribute_name', self.continuous_attribute_name
+        )
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        if self.categorical_attribute_name == self.continuous_attribute_name:
+            raise Exception('Both attribute names are the same')
+
+        basefunctions.check_is_valid_format_str(
+            'continuous_value_type', self.continuous_value_type
+        )
+
+        # Load the lookup file - - - - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        cate_val_dict = {}  # The categorical attribute values to be loaded from
+        # file and their counts.
+        cont_funct_dict = {}  # For each categorical attribute value the details of
+        # the function used for the continuous attribute.
+
+        # Process attribute values from file and their details
+        #
+        for rec_list in lookup_file_data:
+            if len(rec_list) not in [5, 7]:
+                raise Exception(
+                    'Illegal format in lookup file %s: %s'
+                    % (self.lookup_file_name, str(rec_list))
+                )
+            cate_attr_val = rec_list[0].strip()
+            try:
+                cate_attr_count = int(rec_list[1])
+            except:
+                raise Exception(
+                    'Value count given for categorical attribute is '
+                    + 'not an integer number: %s' % (rec_list[1])
+                )
+            cont_attr_funct = rec_list[2].strip()
+
+            if cate_attr_val == '':
+                raise Exception(
+                    'Empty categorical attribute value in lookup file %s'
+                    % (self.lookup_file_name)
+                )
+            if cate_attr_count <= 0:
+                raise Exception(
+                    'Count given for categorical attribute is not '
+                    + 'positive for value "%s" in lookup ' % (cate_attr_val)
+                    + 'file %s' % (self.lookup_file_name)
+                )
+
+            if cate_attr_val in cate_val_dict:
+                raise Exception(
+                    'Attribute values "%s" occurs twice in ' % (cate_attr_val)
+                    + 'lookup file %s' % (self.lookup_file_name)
+                )
+
+            if cont_attr_funct not in ['uniform', 'normal']:
+                raise Exception(
+                    'Illegal continuous attribute function given: "%s"' % (cont_attr_funct)
+                    + ' in lookup file %s' % (self.lookup_file_name)
+                )
+
+            cate_val_dict[cate_attr_val] = cate_attr_count
+
+            # Get function parameters from file data
+            #
+            if cont_attr_funct == 'uniform':
+                cont_attr_funct_min_val = float(rec_list[3])
+                basefunctions.check_is_number(
+                    'cont_attr_funct_min_val', cont_attr_funct_min_val
+                )
+
+                cont_attr_funct_max_val = float(rec_list[4])
+                basefunctions.check_is_number(
+                    'cont_attr_funct_max_val', cont_attr_funct_max_val
+                )
+
+                cont_funct_dict[cate_attr_val] = [
+                    cont_attr_funct,
+                    cont_attr_funct_min_val,
+                    cont_attr_funct_max_val,
+                ]
+
+            elif cont_attr_funct == 'normal':
+                cont_attr_funct_mu = float(rec_list[3])
+                basefunctions.check_is_number('cont_attr_funct_mu', cont_attr_funct_mu)
+
+                cont_attr_funct_sigma = float(rec_list[4])
+                basefunctions.check_is_number(
+                    'cont_attr_funct_sigma', cont_attr_funct_sigma
+                )
+                try:
+                    cont_attr_funct_min_val = float(rec_list[5])
+                except:
+                    cont_attr_funct_min_val = None
+                if cont_attr_funct_min_val != None:
+                    basefunctions.check_is_number(
+                        'cont_attr_funct_min_val', cont_attr_funct_min_val
+                    )
+                try:
+                    cont_attr_funct_max_val = float(rec_list[6])
+                except:
+                    cont_attr_funct_max_val = None
+                if cont_attr_funct_max_val != None:
+                    basefunctions.check_is_number(
+                        'cont_attr_funct_max_val', cont_attr_funct_max_val
+                    )
+
+                cont_funct_dict[cate_attr_val] = [
+                    cont_attr_funct,
+                    cont_attr_funct_mu,
+                    cont_attr_funct_sigma,
+                    cont_attr_funct_min_val,
+                    cont_attr_funct_max_val,
+                ]
+
+        # Generate a list of values according to their counts
+        #
+        cate_attr_val_list = []
+
+        for (cate_attr_val, val_count) in cate_val_dict.items():
+
+            # Append value as many times as given in their counts
+            #
+            new_list = [cate_attr_val] * val_count
+            cate_attr_val_list += new_list
+
+        random.shuffle(cate_attr_val_list)  # Randomly shuffle the list of values
+
+        self.cate_attr_val_list = cate_attr_val_list
+        self.cont_funct_dict = cont_funct_dict
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_values(self):
+        """Method which creates and returns two attribute values, one categorical
+        and one continuous, with the categorical value randomly selected
+        according to the provided frequency distribution, and the continuous
+        value according to the selected function and its parameters.
+        """
+
+        assert self.cate_attr_val_list != []
+
+        cate_attr_val = random.choice(self.cate_attr_val_list)
+
+        # Get the details of the function and generate the continuous value
+        #
+        funct_details = self.cont_funct_dict[cate_attr_val]
+        funct_name = funct_details[0]
+
+        if funct_name == 'uniform':
+            cont_attr_val = random.uniform(funct_details[1], funct_details[2])
+
+        elif funct_name == 'normal':
+            mu = funct_details[1]
+            sigma = funct_details[2]
+            min_val = funct_details[3]
+            max_val = funct_details[4]
+            in_range = False
+
+            cont_attr_val = random.normalvariate(mu, sigma)
+
+            while in_range == False:
+                if ((min_val != None) and (cont_attr_val < min_val)) or (
+                    (max_val != None) and (cont_attr_val > max_val)
+                ):
+                    in_range = False
+                    cont_attr_val = random.normalvariate(mu, sigma)
+                else:
+                    in_range = True
+
+            if min_val != None:
+                assert cont_attr_val >= min_val
+            if max_val != None:
+                assert cont_attr_val <= max_val
+
+        else:
+            raise Exception(('Illegal continuous function given:', funct_name))
+
+        cont_attr_val_str = basefunctions.float_to_str(
+            cont_attr_val, self.continuous_value_type
+        )
+
+        return cate_attr_val, cont_attr_val_str
+
+
+# =============================================================================
+
+
+class GenerateCateCateContCompoundAttribute(GenerateCompoundAttribute):
+    """Generate three attributes, thefirst two containing categorical values and
+    the third containing continuous values, where the values of the second
+    attribute depend upon the values in the first attribute, and the values
+    of the third attribute depend upon both the values of the first and second
+    attribute.
+
+    This for example allows the modelling of:
+    - blood pressure depending upon gender and city of residence values, or
+    - salary depending upon gender and profession values.
+
+    The arguments that have to be set when this attribute type is initialised
+    are:
+
+    categorical1_attribute_name  The name of the first categorical attribute
+                                 that will be generated. This name will be
+                                 used in the header line to be written into
+                                 the output file.
+
+    categorical2_attribute_name  The name of the second categorical attribute
+                                 that will be generated. This name will be
+                                 used in the header line to be written into
+                                 the output file.
+
+    continuous_attribute_name    The name of the continuous attribute that
+                                 will be generated. This name will be used in
+                                 the header line to be written into the output
+                                 file.
+
+    lookup_file_name              Name of the file which contains the values
+                                  of the first categorical attribute, and for
+                                  each of these values the names of the
+                                  categories and their counts of the second
+                                  categorical attribute, and for each of these
+                                  values the name of a function (and its
+                                  parameters) that is used to generate the
+                                  continuous values. This file format is
+                                  further explained below.
+
+    has_header_line               A flag, set to True or False, that has to be
+                                  set according to if the look-up file starts
+                                  with a header line or not.
+
+    unicode_encoding              The Unicode encoding (a string name) of the
+                                  file.
+
+    continuous_value_type         The format of how continuous values are
+                                  returned when they are generated. Possible
+                                  values are 'int', so integer values are
+                                  returned; or 'float1', 'float2', to
+                                  'float9', in which case floating-point
+                                  values with the specified number of digits
+                                  behind the comma are returned.
+
+    The format of the look-up file is:
+
+    # Comment lines start with the # character
+    cate_attr1_val1,count
+    cate_attr2_val1,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr2_val2,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr2_val3,count,funct_name,funct_param_1,...,funct_param_N
+    ...
+    cate_attr2_valX,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr1_val2,count
+    cate_attr2_val1,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr2_val2,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr2_val3,count,funct_name,funct_param_1,...,funct_param_N
+    ...
+    cate_attr2_valX,count,funct_name,funct_param_1,...,funct_param_N
+    cate_attr1_val3,count
+    ...
+
+
+    The look-up file is a comma separated values (CSV) file with the following
+    structure:
+
+    A) One row that contains two values:
+       1) A categorical value of the first attribute. For all possible values
+          of the first categorical attribute, one row must be specified in
+          this look-up file.
+       2) The count of this categorical value (a positive integer number).
+          This determines the likelihood of how often a certain categorical
+          value will be chosen.
+
+    B) After a row with two values, as described under A), one or more rows
+       containing the following values in columns must be given:
+       1) A categorical value from the second categorical attribute.
+       2) The count of this categorical value (a positive integer number).
+          This determines the likelihood of how often a certain categorical
+          value will be chosen.
+      3) A function which generates the continuous value for this categorical
+         value. Implemented functions currently are:
+         - uniform
+         - normal
+      4) The parameters required for the function that generates the
+         continuous values. They are:
+         - uniform:  min_val, max_val
+         - normal:   mu, sigma, min_val, max_val
+                     (min_val and max_val can be set to None in which case no
+                     minimum or maximum is enforced)
+
+    Example:
+      male,60
+      canberra,20,uniform,50000,90000
+      sydney,30,normal,75000,50000,20000,None
+      melbourne,30,uniform,35000,200000
+      perth,20,normal,55000,250000,15000,None
+      female,40
+      canberra,10,normal,45000,10000,None,150000
+      sydney,40,uniform,60000,200000
+      melbourne,20,uniform,50000,1750000
+      brisbane,30,normal,55000,20000,20000,100000
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        # General attributes for all data set generators
+        #
+        self.number_of_atttributes = 3
+        self.attribute_type = 'Compound-Categorical-Categorical-Continuous'
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('categorical1'):
+                basefunctions.check_is_non_empty_string(
+                    'categorical1_attribute_name', value
+                )
+                self.categorical1_attribute_name = value
+
+            elif keyword.startswith('categorical2'):
+                basefunctions.check_is_non_empty_string(
+                    'categorical2_attribute_name', value
+                )
+                self.categorical2_attribute_name = value
+
+            elif keyword.startswith('continuous_a'):
+                basefunctions.check_is_non_empty_string('continuous_attribute_name', value)
+                self.continuous_attribute_name = value
+
+            elif keyword.startswith('continuous_v'):
+                basefunctions.check_is_non_empty_string('continuous_value_type', value)
+                basefunctions.check_is_valid_format_str('continuous_value_type', value)
+                self.continuous_value_type = value
+
+            elif keyword.startswith('look'):
+                basefunctions.check_is_non_empty_string('lookup_file_name', value)
+                self.lookup_file_name = value
+
+            elif keyword.startswith('has'):
+                basefunctions.check_is_flag('has_header_line', value)
+                self.has_header_line = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_is_non_empty_string('unicode_encoding', value)
+                self.unicode_encoding = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string(
+            'categorical1_attribute_name', self.categorical1_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'categorical2_attribute_name', self.categorical2_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous_attribute_name', self.continuous_attribute_name
+        )
+        basefunctions.check_is_non_empty_string('lookup_file_name', self.lookup_file_name)
+        basefunctions.check_is_flag('has_header_line', self.has_header_line)
+        basefunctions.check_is_non_empty_string('unicode_encoding', self.unicode_encoding)
+
+        if (
+            (self.categorical1_attribute_name == self.categorical2_attribute_name)
+            or (self.categorical1_attribute_name == self.continuous_attribute_name)
+            or (self.categorical2_attribute_name == self.continuous_attribute_name)
+        ):
+            raise Exception('Not all attribute names are different.')
+
+        basefunctions.check_is_valid_format_str(
+            'continuous_value_type', self.continuous_value_type
+        )
+
+        # Load the lookup file - - - - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        header_list, lookup_file_data = basefunctions.read_csv_file(
+            self.lookup_file_name, self.unicode_encoding, self.has_header_line
+        )
+
+        cate_val1_dict = {}  # The categorical values from attribute 1 to be
+        # loaded from file, and their counts.
+
+        cate_val2_dict = {}  # The categorical values from attribute 1 as keys
+        # and lists of categorical values (according to their
+        # counts) from attribute 2 as values.
+
+        cont_funct_dict = {}  # For each pair of categorical attribute values the
+        # details of the function used for the continuous
+        # attribute.
+
+        # Process attribute values from file and their details
+        #
+        list_counter = 0  # Counter in the list of lookup file data
+        num_file_rows = len(lookup_file_data)
+        rec_list = lookup_file_data[list_counter]
+
+        while list_counter < num_file_rows:  # Process one row after another
+
+            if len(rec_list) < 2:  # Need at least one categorical value and count
+                raise Exception(
+                    'Illegal format in lookup file %s: %s'
+                    % (self.lookup_file_name, str(rec_list))
+                )
+            cate_attr1_val = rec_list[0].strip()
+            try:
+                cate_attr1_count = int(rec_list[1])
+            except:
+                raise Exception(
+                    'Value count given for attribute 1 is not an '
+                    + 'integer number: %s' % (rec_list[1])
+                )
+
+            if cate_attr1_val == '':
+                raise Exception(
+                    'Empty categorical attribute value 1 in lookup '
+                    + 'file %s' % (self.lookup_file_name)
+                )
+            basefunctions.check_is_positive('cate_attr1_count', cate_attr1_count)
+
+            if cate_attr1_val in cate_val1_dict:
+                raise Exception(
+                    'Attribute value "%s" occurs twice in ' % (cate_attr1_val)
+                    + 'lookup file %s' % (self.lookup_file_name)
+                )
+
+            cate_val1_dict[cate_attr1_val] = cate_attr1_count
+
+            # Loop to process values of the second categorical attribute and the
+            # corresponding continuous functions
+            #
+            list_counter += 1
+            rec_list = lookup_file_data[list_counter]  # Get values from next line
+
+            this_cate_val2_dict = {}  # Values of categorical attribute 2
+            this_cont_funct_dict = {}
+
+            # As long as there are data from the second categorical attribute
+            #
+            while len(rec_list) > 2:
+                cate_attr2_val = rec_list[0].strip()
+                try:
+                    cate_attr2_count = int(rec_list[1])
+                except:
+                    raise Exception(
+                        'Value count given for categorical attribute 2 '
+                        + 'is not an integer number: %s' % (rec_list[1])
+                    )
+                cont_attr_funct = rec_list[2].strip()
+
+                if cate_attr2_val == '':
+                    raise Exception(
+                        'Empty categorical attribute 2 value in lookup '
+                        + 'file %s' % (self.lookup_file_name)
+                    )
+                basefunctions.check_is_positive('cate_attr2_count', cate_attr2_count)
+
+                if cate_attr2_val in this_cate_val2_dict:
+                    raise Exception(
+                        'Attribute value "%s" occurs twice in ' % (cate_attr2_val)
+                        + 'lookup file %s' % (self.lookup_file_name)
+                    )
+
+                if cont_attr_funct not in ['uniform', 'normal']:
+                    raise Exception(
+                        'Illegal continuous attribute function '
+                        + 'given: "%s"' % (cont_attr_funct)
+                        + ' in lookup file %s' % (self.lookup_file_name)
+                    )
+
+                this_cate_val2_dict[cate_attr2_val] = cate_attr2_count
+
+                # Get function parameters from file data
+                #
+                if cont_attr_funct == 'uniform':
+                    cont_attr_funct_min_val = float(rec_list[3])
+                    basefunctions.check_is_number(
+                        'cont_attr_funct_min_val', cont_attr_funct_min_val
+                    )
+                    cont_attr_funct_max_val = float(rec_list[4])
+                    basefunctions.check_is_number(
+                        'cont_attr_funct_max_val', cont_attr_funct_max_val
+                    )
+
+                    this_cont_funct_dict[cate_attr2_val] = [
+                        cont_attr_funct,
+                        cont_attr_funct_min_val,
+                        cont_attr_funct_max_val,
+                    ]
+                elif cont_attr_funct == 'normal':
+                    cont_attr_funct_mu = float(rec_list[3])
+                    cont_attr_funct_sigma = float(rec_list[4])
+                    try:
+                        cont_attr_funct_min_val = float(rec_list[5])
+                    except:
+                        cont_attr_funct_min_val = None
+                    if cont_attr_funct_min_val != None:
+                        basefunctions.check_is_number(
+                            'cont_attr_funct_min_val', cont_attr_funct_min_val
+                        )
+                    try:
+                        cont_attr_funct_max_val = float(rec_list[6])
+                    except:
+                        cont_attr_funct_max_val = None
+                    if cont_attr_funct_max_val != None:
+                        basefunctions.check_is_number(
+                            'cont_attr_funct_max_val', cont_attr_funct_max_val
+                        )
+                    this_cont_funct_dict[cate_attr2_val] = [
+                        cont_attr_funct,
+                        cont_attr_funct_mu,
+                        cont_attr_funct_sigma,
+                        cont_attr_funct_min_val,
+                        cont_attr_funct_max_val,
+                    ]
+
+                list_counter += 1
+                if list_counter < num_file_rows:
+                    rec_list = lookup_file_data[list_counter]
+                else:
+                    rec_list = []
+
+            # Generate a list of categorical 2 values according to their counts
+            #
+            cate_attr2_val_list = []
+
+            for (cate_attr2_val, val2_count) in this_cate_val2_dict.items():
+
+                # Append value as many times as given in their counts
+                #
+                new_list = [cate_attr2_val] * val2_count
+                cate_attr2_val_list += new_list
+
+            random.shuffle(cate_attr2_val_list)  # Randomly shuffle the list of values
+
+            cate_val2_dict[cate_attr1_val] = cate_attr2_val_list
+
+            # Store function data for each combination of categorial values
+            #
+            for cate_attr2_val in this_cont_funct_dict:
+                cont_dict_key = cate_attr1_val + '-' + cate_attr2_val
+                cont_funct_dict[cont_dict_key] = this_cont_funct_dict[cate_attr2_val]
+
+        # Generate a list of values according to their counts for attribute 1
+        #
+        cate_attr1_val_list = []
+
+        for (cate_attr1_val, val1_count) in cate_val1_dict.items():
+
+            # Append value as many times as given in their counts
+            #
+            new_list = [cate_attr1_val] * val1_count
+            cate_attr1_val_list += new_list
+
+        random.shuffle(cate_attr1_val_list)  # Randomly shuffle the list of values
+
+        self.cate_attr1_val_list = cate_attr1_val_list
+        self.cate_val2_dict = cate_val2_dict
+        self.cont_funct_dict = cont_funct_dict
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_values(self):
+        """Method which creates and returns two categorical attribute values and
+        one continuous value, where the second categorical value depends upon
+        the first value, andthe continuous value depends on both categorical
+        values. The two categorical values are randomly selected according to
+        the provided frequency distributions, while  the continuous value is
+        generated according to the selected function and its parameters.
+        """
+
+        assert self.cate_attr1_val_list != []
+        assert self.cate_val2_dict != {}
+        assert self.cont_funct_dict != {}
+
+        cate_attr1_val = random.choice(self.cate_attr1_val_list)
+
+        cate_attr2_list = self.cate_val2_dict[cate_attr1_val]
+
+        cate_attr2_val = random.choice(cate_attr2_list)
+
+        # Get the details of the function and generate the continuous value
+        #
+        cont_dict_key = cate_attr1_val + '-' + cate_attr2_val
+        funct_details = self.cont_funct_dict[cont_dict_key]
+        funct_name = funct_details[0]
+
+        if funct_name == 'uniform':
+            cont_attr_val = random.uniform(funct_details[1], funct_details[2])
+
+        elif funct_name == 'normal':
+            mu = funct_details[1]
+            sigma = funct_details[2]
+            min_val = funct_details[3]
+            max_val = funct_details[4]
+            in_range = False
+
+            cont_attr_val = random.normalvariate(mu, sigma)
+
+            while in_range == False:
+                if ((min_val != None) and (cont_attr_val < min_val)) or (
+                    (max_val != None) and (cont_attr_val > max_val)
+                ):
+                    in_range = False
+                    cont_attr_val = random.normalvariate(mu, sigma)
+                else:
+                    in_range = True
+
+            if min_val != None:
+                assert cont_attr_val >= min_val
+            if max_val != None:
+                assert cont_attr_val <= max_val
+
+        else:
+            raise Exception(('Illegal continuous function given:', funct_name))
+
+        cont_attr_val_str = basefunctions.float_to_str(
+            cont_attr_val, self.continuous_value_type
+        )
+
+        return cate_attr1_val, cate_attr2_val, cont_attr_val_str
+
+
+# =============================================================================
+
+
+class GenerateContContCompoundAttribute(GenerateCompoundAttribute):
+    """Generate two continuous attribute values, where the value of the second
+    attribute depends upon the value of the first attribute.
+
+    This for example allows the modelling of:
+    - salary values that depend upon age values, or
+    - blood pressure values that depend upon age values.
+
+    The arguments that have to be set when this attribute type is initialised
+    are:
+
+    continuous1_attribute_name  The name of the first continuous attribute
+                                that will be generated. This name will be
+                                used in the header line to be written into
+                                the output file.
+
+    continuous2_attribute_name  The name of the second continuous attribute
+                                that will be generated. This name will be
+                                used in the header line to be written into
+                                the output file.
+
+    continuous1_funct_name      The name of the function that is used to
+                                randomly generate the values of the first
+                                attribute. Implemented functions currently
+                                are:
+                                - uniform
+                                - normal
+
+    continuous1_funct_param     A list with the parameters required for the
+                                function that generates the continuous values
+                                in the first attribute. They are:
+                                - uniform:  [min_val, max_val]
+                                - normal:   [mu, sigma, min_val, max_val]
+                                            (min_val and max_val can be set
+                                            to None in which case no minimum
+                                            or maximum is enforced)
+
+    continuous2_function        A Python function that has a floating-point
+                                value as input (assumed to be a value
+                                generated for the first attribute) and that
+                                returns a floating-point value (assumed to be
+                                the value of the second attribute).
+
+    continuous1_value_type      The format of how the continuous values in
+                                the first attribute are returned when they
+                                are generated. Possible values are 'int', so
+                                integer values are generated; or 'float1',
+                                'float2', to 'float9', in which case
+                                floating-point values with the specified
+                                number of digits behind the comma are
+                                generated.
+
+    continuous2_value_type      The same as for the first attribute.
+    """
+
+    # ---------------------------------------------------------------------------
+
+    def __init__(self, **kwargs):
+        """Constructor. Process the derived keywords first, then call the base
+        class constructor.
+        """
+
+        # General attributes for all data set generators
+        #
+        self.number_of_atttributes = 2
+        self.attribute_type = 'Compound-Continuous-Continuous'
+
+        for (keyword, value) in kwargs.items():
+
+            if keyword.startswith('continuous1_a'):
+                basefunctions.check_is_non_empty_string(
+                    'continuous1_attribute_name', value
+                )
+                self.continuous1_attribute_name = value
+
+            elif keyword.startswith('continuous2_a'):
+                basefunctions.check_is_non_empty_string(
+                    'continuous2_attribute_name', value
+                )
+                self.continuous2_attribute_name = value
+
+            elif keyword.startswith('continuous1_funct_n'):
+                basefunctions.check_is_non_empty_string('continuous1_funct_name', value)
+                self.continuous1_funct_name = value
+
+            elif keyword.startswith('continuous1_funct_p'):
+                basefunctions.check_is_list('continuous1_funct_param', value)
+                self.continuous1_funct_param = value
+
+            elif keyword.startswith('continuous2_f'):
+                basefunctions.check_is_function_or_method('continuous2_function', value)
+                self.continuous2_function = value
+
+            elif keyword.startswith('continuous1_v'):
+                basefunctions.check_is_non_empty_string('continuous1_value_type', value)
+                basefunctions.check_is_valid_format_str('continuous1_value_type', value)
+                self.continuous1_value_type = value
+
+            elif keyword.startswith('continuous2_v'):
+                basefunctions.check_is_non_empty_string('continuous2_value_type', value)
+                basefunctions.check_is_valid_format_str('continuous2_value_type', value)
+                self.continuous2_value_type = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string(
+            'continuous1_attribute_name', self.continuous1_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous2_attribute_name', self.continuous2_attribute_name
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous1_funct_name', self.continuous1_funct_name
+        )
+        basefunctions.check_is_list(
+            'continuous1_funct_param', self.continuous1_funct_param
+        )
+        basefunctions.check_is_function_or_method(
+            'continuous2_function', self.continuous2_function
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous1_value_type', self.continuous1_value_type
+        )
+        basefunctions.check_is_non_empty_string(
+            'continuous2_value_type', self.continuous2_value_type
+        )
+
+        if self.continuous1_attribute_name == self.continuous2_attribute_name:
+            raise Exception('Both attribute names are the same')
+
+        basefunctions.check_is_valid_format_str(
+            'continuous1_value_type', self.continuous1_value_type
+        )
+        basefunctions.check_is_valid_format_str(
+            'continuous2_value_type', self.continuous2_value_type
+        )
+
+        # Check that the function for attribute 2 does return a float value
+        #
+        funct_ret = self.continuous2_function(1.0)
+        if not isinstance(funct_ret, float):
+            raise Exception(
+                (
+                    'Function provided for attribute 2 does not return'
+                    + ' a floating-point value:',
+                    type(funct_ret),
+                )
+            )
+
+        # Check type and number of parameters given for attribute 1 functions
+        #
+        if self.continuous1_funct_name not in ['uniform', 'normal']:
+            raise Exception(
+                'Illegal continuous attribute 1 function given: "%s"'
+                % (self.continuous1_funct_name)
+            )
+
+        # Get function parameters from file data
+        #
+        if self.continuous1_funct_name == 'uniform':
+            assert len(self.continuous1_funct_param) == 2
+
+            cont_attr1_funct_min_val = self.continuous1_funct_param[0]
+            cont_attr1_funct_max_val = self.continuous1_funct_param[1]
+            basefunctions.check_is_number(
+                'cont_attr1_funct_min_val', cont_attr1_funct_min_val
+            )
+            basefunctions.check_is_number(
+                'cont_attr1_funct_max_val', cont_attr1_funct_max_val
+            )
+
+            assert cont_attr1_funct_min_val < cont_attr1_funct_max_val
+
+            self.attr1_funct_param = [cont_attr1_funct_min_val, cont_attr1_funct_max_val]
+
+        elif self.continuous1_funct_name == 'normal':
+            assert len(self.continuous1_funct_param) == 4
+
+            cont_attr1_funct_mu = self.continuous1_funct_param[0]
+            cont_attr1_funct_sigma = self.continuous1_funct_param[1]
+            cont_attr1_funct_min_val = self.continuous1_funct_param[2]
+            cont_attr1_funct_max_val = self.continuous1_funct_param[3]
+
+            basefunctions.check_is_number('cont_attr1_funct_mu', cont_attr1_funct_mu)
+            basefunctions.check_is_number('cont_attr1_funct_sigma', cont_attr1_funct_sigma)
+
+            basefunctions.check_is_positive(
+                'cont_attr1_funct_sigma', cont_attr1_funct_sigma
+            )
+
+            if cont_attr1_funct_min_val != None:
+                basefunctions.check_is_number(
+                    'cont_attr1_funct_min_val', cont_attr1_funct_min_val
+                )
+                assert cont_attr1_funct_min_val <= cont_attr1_funct_mu
+
+            if cont_attr1_funct_max_val != None:
+                basefunctions.check_is_number(
+                    'cont_attr1_funct_max_val', cont_attr1_funct_max_val
+                )
+                assert cont_attr1_funct_max_val >= cont_attr1_funct_mu
+
+            if (cont_attr1_funct_min_val != None) and (cont_attr1_funct_max_val) != None:
+                assert cont_attr1_funct_min_val < cont_attr1_funct_max_val
+
+            self.attr1_funct_param = [
+                cont_attr1_funct_mu,
+                cont_attr1_funct_sigma,
+                cont_attr1_funct_min_val,
+                cont_attr1_funct_max_val,
+            ]
+
+    # ---------------------------------------------------------------------------
+
+    def create_attribute_values(self):
+        """Method which creates and returns two continuous attribute values, with
+        the the first continuous value according to the selected function and
+        its parameters, and the second value depending upon the first value.
+        """
+
+        # Get the details of the function and generate the first continuous value
+        #
+        funct_name = self.continuous1_funct_name
+        funct_details = self.attr1_funct_param
+
+        if funct_name == 'uniform':
+            cont_attr1_val = random.uniform(funct_details[0], funct_details[1])
+
+        elif funct_name == 'normal':
+            mu = funct_details[0]
+            sigma = funct_details[1]
+            min_val = funct_details[2]
+            max_val = funct_details[3]
+            in_range = False
+
+            cont_attr1_val = random.normalvariate(mu, sigma)
+
+            while in_range == False:
+                if ((min_val != None) and (cont_attr1_val < min_val)) or (
+                    (max_val != None) and (cont_attr1_val > max_val)
+                ):
+                    in_range = False
+                    cont_attr1_val = random.normalvariate(mu, sigma)
+                else:
+                    in_range = True
+
+            if min_val != None:
+                assert cont_attr1_val >= min_val
+            if max_val != None:
+                assert cont_attr1_val <= max_val
+
+        else:
+            raise Exception(('Illegal continuous function given:', funct_name))
+
+        # Generate the second attribute value
+        #
+        cont_attr2_val = self.continuous2_function(cont_attr1_val)
+
+        cont_attr1_val_str = basefunctions.float_to_str(
+            cont_attr1_val, self.continuous1_value_type
+        )
+        cont_attr2_val_str = basefunctions.float_to_str(
+            cont_attr2_val, self.continuous2_value_type
+        )
+
+        return cont_attr1_val_str, cont_attr2_val_str
+
+
+# =============================================================================
+# Classes for generating a data set
+# =============================================================================
+
+
+class GenerateDataSet:
+    """Base class for data set generation.
+
+    This class and all of its derived classes provide methods that allow the
+    generation of a synthetic data set according to user specifications.
+
+    The following arguments need to be set when a GenerateDataSet instance is
+    initialised:
+
+    output_file_name     The name of the file that will be generated. This
+                         will be a comma separated values (CSV) file. If the
+                         file name given does not end with the extension
+                         '.csv' then this extension will be added.
+
+    write_header_line    A flag (True or false) indicating if a header line
+                         with the attribute (field) names is to be written at
+                         the beginning of the output file or not. The default
+                         for this argument is True.
+
+    rec_id_attr_name     The name of the record identifier attribute. This
+                         name must be different from the names of all other
+                         generated attributes. Record identifiers will be
+                         unique values for each generated record.
+
+    number_of_records    The number of records that are to be generated. This
+                         will correspond to the number of 'original' records
+                         that are generated.
+
+    attribute_name_list  The list of attributes (fields) that are to be
+                         generated for each record, and the sequence how they
+                         are to be written into the output file. Each element
+                         in this list must be an attribute name. These names
+                         will become the header line of the output file (if
+                         a header line is to be written).
+
+    attribute_data_list  A list which contains the actual attribute objects
+                         (from the classes GenerateAttribute and
+                         GenerateCompoundAttribute and their respective
+                         derived classes).
+
+    unicode_encoding     The Unicode encoding (a string name) of the file.
+    """
+
+    # ---------------------------------------------------------------------------
+    def __init__(self, **kwargs):
+        """Constructor, set general attributes."""
+
+        # General attributes for all data set generators
+        #
+        self.output_file_name = None
+        self.write_header_line = True
+        self.rec_id_attr_name = None
+        self.number_of_records = 0
+        self.attribute_name_list = None
+        self.attribute_data_list = None
+        self.unicode_encoding = None
+        self.missing_val_str = ''
+
+        # The following dictionary will contain the generated records, with the
+        # dictionary keys being the record identifiers (unique for each record),
+        # while the dictionary values will be lists containing the actual attribute
+        # values of these generated records.
+        #
+        self.rec_dict = {}
+
+        for (keyword, value) in kwargs.items():  # Process keyword arguments
+
+            if keyword.startswith('output'):
+                basefunctions.check_is_non_empty_string('output_file_name', value)
+
+                # Make sure the file extension is correct
+                #
+                if value.endswith('.csv') == False:
+                    value = value + '.csv'
+                self.output_file_name = value
+
+            elif keyword.startswith('write'):
+                basefunctions.check_is_flag('write_header_line', value)
+                self.write_header_line = value
+
+            elif keyword.startswith('rec'):
+                basefunctions.check_is_non_empty_string('rec_id_attr_name', value)
+                self.rec_id_attr_name = value
+
+            elif keyword.startswith('number'):
+                basefunctions.check_is_integer('number_of_records', value)
+                basefunctions.check_is_positive('number_of_records', value)
+                self.number_of_records = value
+
+            elif keyword.startswith('attribute_name'):
+                basefunctions.check_is_list('attribute_name_list', value)
+                if not value:
+                    raise Exception('attribute_name_list is empty: %s' % (type(value)))
+                self.attribute_name_list = value
+
+            elif keyword.startswith('attribute_data'):
+                basefunctions.check_is_list('attribute_data_list', value)
+                self.attribute_data_list = value
+
+            elif keyword.startswith('unicode'):
+                basefunctions.check_unicode_encoding_exists(value)
+                self.unicode_encoding = value
+
+            else:
+                raise Exception(
+                    'Illegal constructor argument keyword: "%s"' % (str(keyword))
+                )
+
+        # Check if the necessary variables have been set
+        #
+        basefunctions.check_is_non_empty_string('output_file_name', self.output_file_name)
+        basefunctions.check_is_non_empty_string('rec_id_attr_name', self.rec_id_attr_name)
+        basefunctions.check_is_integer('number_of_records', self.number_of_records)
+        basefunctions.check_is_positive('number_of_records', self.number_of_records)
+        basefunctions.check_is_list('attribute_name_list', self.attribute_name_list)
+        basefunctions.check_is_list('attribute_data_list', self.attribute_data_list)
+        basefunctions.check_unicode_encoding_exists(self.unicode_encoding)
+
+        # Remove potential duplicate entries in the attribute data list
+        #
+        attr_data_set = set()
+        new_attr_data_list = []
+        for attr_data in self.attribute_data_list:
+            if attr_data not in attr_data_set:
+                attr_data_set.add(attr_data)
+                new_attr_data_list.append(attr_data)
+        self.attribute_data_list = new_attr_data_list
+
+        # Check if the attributes listed in the attribute name list are all
+        # different, i.e. no attribute is listed twice, that their names are all
+        # different from the record identifier attribute name.
+        #
+        attr_name_set = set()
+        for attr_name in self.attribute_name_list:
+            if attr_name == self.rec_id_attr_name:
+                raise Exception(
+                    'Attribute given has the same name as the record '
+                    + 'identifier attribute'
+                )
+            if attr_name in attr_name_set:
+                raise Exception('Attribute name "%s" is given twice' % (attr_name))
+            attr_name_set.add(attr_name)
+        assert len(attr_name_set) == len(self.attribute_name_list)
+
+        # Check if the attribute names listed in the attribute data list are all
+        # different, i.e. no attribute is listed twice, that their names are all
+        # different from the record identifier attribute name.
+        #
+        attr_name_set = set()
+        for attr_data in self.attribute_data_list:
+
+            if attr_data.attribute_type == 'Compound-Categorical-Categorical':
+                attr1_name = attr_data.categorical1_attribute_name
+                attr2_name = attr_data.categorical2_attribute_name
+                attr3_name = ''
+
+            elif attr_data.attribute_type == 'Compound-Categorical-Continuous':
+                attr1_name = attr_data.categorical_attribute_name
+                attr2_name = attr_data.continuous_attribute_name
+                attr3_name = ''
+
+            elif attr_data.attribute_type == 'Compound-Continuous-Continuous':
+                attr1_name = attr_data.continuous1_attribute_name
+                attr2_name = attr_data.continuous2_attribute_name
+                attr3_name = ''
+
+            elif attr_data.attribute_type == 'Compound-Categorical-Categorical-Continuous':
+                attr1_name = attr_data.categorical1_attribute_name
+                attr2_name = attr_data.categorical2_attribute_name
+                attr3_name = attr_data.continuous_attribute_name
+
+            else:  # A single attribute
+                attr1_name = attr_data.attribute_name
+                attr2_name = ''
+                attr3_name = ''
+
+            for attr_name in [attr1_name, attr2_name, attr3_name]:
+                if attr_name != '':
+                    if attr_name == self.rec_id_attr_name:
+                        raise Exception(
+                            'Attribute given has the same name as the '
+                            + 'record identifier attribute'
+                        )
+                    if attr_name in attr_name_set:
+                        raise Exception(
+                            'Attribute name "%s" is given twice' % (attr_name)
+                            + ' in attribute data definitions'
+                        )
+                    attr_name_set.add(attr_name)
+
+        # Check that there is an attribute definition provided for each attribute
+        # listed in the attribute name list.
+        #
+        for attr_name in self.attribute_name_list:
+            found_attr_name = False
+            for attr_data in self.attribute_data_list:
+
+                # Get names from attribute data
+                #
+                if attr_data.attribute_type == 'Compound-Categorical-Categorical':
+                    if (attr_name == attr_data.categorical1_attribute_name) or (
+                        attr_name == attr_data.categorical2_attribute_name
+                    ):
+                        found_attr_name = True
+                elif attr_data.attribute_type == 'Compound-Categorical-Continuous':
+                    if (attr_name == attr_data.categorical_attribute_name) or (
+                        attr_name == attr_data.continuous_attribute_name
+                    ):
+                        found_attr_name = True
+                elif attr_data.attribute_type == 'Compound-Continuous-Continuous':
+                    if (attr_name == attr_data.continuous1_attribute_name) or (
+                        attr_name == attr_data.continuous2_attribute_name
+                    ):
+                        found_attr_name = True
+                elif (
+                    attr_data.attribute_type
+                    == 'Compound-Categorical-Categorical-Continuous'
+                ):
+                    if (
+                        (attr_name == attr_data.categorical1_attribute_name)
+                        or (attr_name == attr_data.categorical2_attribute_name)
+                        or (attr_name == attr_data.continuous_attribute_name)
+                    ):
+                        found_attr_name = True
+                else:  # A single attribute
+                    if attr_name == attr_data.attribute_name:
+                        found_attr_name = True
+
+            if found_attr_name == False:
+                raise Exception(
+                    'No attribute data available for attribute "%s"' % (attr_name)
+                )
+
+    # ---------------------------------------------------------------------------
+
+    def generate(self):
+        """Method which runs the generation process and generates the specified
+        number of records.
+
+        This method return a list containing the 'number_of_records' generated
+        records, each being a dictionary with the keys being attribute names and
+        values the corresponding attribute values.
+        """
+
+        attr_name_list = self.attribute_name_list  # Short-hands to increase speed
+        rec_dict = self.rec_dict
+        miss_val_str = self.missing_val_str
+
+        num_rec_num_digit = len(str(self.number_of_records)) - 1  # For digit padding
+
+        print()
+        print('Generate records with attributes:')
+        print(' ', attr_name_list)
+        print()
+
+        for rec_id in range(self.number_of_records):
+            rec_id_str = 'rec-%s-org' % (str(rec_id).zfill(num_rec_num_digit))
+
+            this_rec_dict = {}  # The generated attribute values (attribute names as
+            # keys, attribute values as values)
+            this_rec_list = []  # List of attribute values of the generated data set
+
+            for attr_data in self.attribute_data_list:
+
+                if attr_data.attribute_type == 'Compound-Categorical-Categorical':
+                    attr1_name = attr_data.categorical1_attribute_name
+                    attr2_name = attr_data.categorical2_attribute_name
+                    attr1_val, attr2_val = attr_data.create_attribute_values()
+                    this_rec_dict[attr1_name] = attr1_val
+                    this_rec_dict[attr2_name] = attr2_val
+
+                elif attr_data.attribute_type == 'Compound-Categorical-Continuous':
+                    attr1_name = attr_data.categorical_attribute_name
+                    attr2_name = attr_data.continuous_attribute_name
+                    attr1_val, attr2_val = attr_data.create_attribute_values()
+                    this_rec_dict[attr1_name] = attr1_val
+                    this_rec_dict[attr2_name] = attr2_val
+
+                elif attr_data.attribute_type == 'Compound-Continuous-Continuous':
+                    attr1_name = attr_data.continuous1_attribute_name
+                    attr2_name = attr_data.continuous2_attribute_name
+                    attr1_val, attr2_val = attr_data.create_attribute_values()
+                    this_rec_dict[attr1_name] = attr1_val
+                    this_rec_dict[attr2_name] = attr2_val
+
+                elif (
+                    attr_data.attribute_type
+                    == 'Compound-Categorical-Categorical-Continuous'
+                ):
+                    attr1_name = attr_data.categorical1_attribute_name
+                    attr2_name = attr_data.categorical2_attribute_name
+                    attr3_name = attr_data.continuous_attribute_name
+                    attr1_val, attr2_val, attr3_val = attr_data.create_attribute_values()
+                    this_rec_dict[attr1_name] = attr1_val
+                    this_rec_dict[attr2_name] = attr2_val
+                    this_rec_dict[attr3_name] = attr3_val
+
+                else:  # A single attribute
+                    attr_name = attr_data.attribute_name
+                    attr_val = attr_data.create_attribute_value()
+                    this_rec_dict[attr_name] = attr_val
+
+            # Compile output record
+            #
+            for attr_name in attr_name_list:
+                attr_val = this_rec_dict.get(attr_name, miss_val_str)
+                assert isinstance(attr_val, str), attr_val
+                this_rec_list.append(attr_val)
+
+            rec_dict[rec_id_str] = this_rec_list
+
+            print('Generated record with ID: %s' % (rec_id_str))
+            print('  %s' % (str(this_rec_list)))
+            print()
+
+        print('Generated %d records' % (self.number_of_records))
+        print()
+        print('------------------------------------------------------------------')
+        print()
+
+        return rec_dict
+
+    # ---------------------------------------------------------------------------
+
+    def write(self):
+        """Write the generated records into the defined output file."""
+
+        rec_id_list = list(self.rec_dict.keys())
+        rec_id_list.sort()
+
+        # Convert record dictionary into a list, with record identifier added
+        #
+        rec_list = []
+
+        for rec_id in rec_id_list:
+            this_rec_list = [rec_id] + self.rec_dict[rec_id]
+            rec_list.append(this_rec_list)
+
+        header_list = [self.rec_id_attr_name] + self.attribute_name_list
+        basefunctions.write_csv_file(
+            self.output_file_name, self.unicode_encoding, header_list, rec_list
+        )

setup.py

@@ -0,0 +1,36 @@
+import pathlib
+from setuptools import setup, find_packages
+
+HERE = pathlib.Path(__file__).parent
+README = (HERE / 'README.md').read_text()
+
+
+def read_requirements(reqs_path):
+    with open(reqs_path, encoding='utf8') as f:
+        reqs = [
+            line.strip()
+            for line in f
+            if not line.strip().startswith('#') and not line.strip().startswith('--')
+        ]
+    return reqs
+
+
+setup(
+    name="geco_data_generator",
+    version="0.0.1",
+    description="kg-geco_data_generator",
+    long_description=README,
+    long_description_content_type='text/markdown',
+    url='https://dmm.anu.edu.au/geco/',
+    author='',
+    author_email='',
+    python_requires='>=3.7',
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Topic :: Scientific/Engineering',
+    ],
+    packages=find_packages(exclude=['tests*', 'scripts', 'utils']),
+    include_package_data=True,
+    install_requires=read_requirements(HERE / 'requirements.txt'),
+)

tests/attrgenfunct_test.py

@@ -0,0 +1,922 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+import random
+import time
+import unittest
+
+from geco_data_generator import attrgenfunct
+
+random.seed(42)
+
+# Define the number of tests to be done for the functionality tests
+num_tests = 10000
+
+# Define argument test cases here
+test_argument_data_dict = {
+    ('attrgenfunct', 'n/a', 'generate_uniform_value'): {
+        'min_val': [
+            [
+                [-10, 10, 'int'],
+                [10, 110, 'float1'],
+                [1110.0, 11011.9, 'float2'],
+                [-1110.0, -11.9, 'float9'],
+                [-51110, 1247, 'float7'],
+            ],
+            [
+                ['-10', 10, 'int'],
+                [None, 10, 'float1'],
+                [{}, 11011.9, 'float2'],
+                ["-1110.0", -11.9, 'float9'],
+                ['int', 1247, 'float7'],
+            ],
+        ],
+        'max_val': [
+            [
+                [-10, 10, 'int'],
+                [10, 110, 'float1'],
+                [1110.0, 11011.9, 'float2'],
+                [-1110.0, -11.9, 'float9'],
+                [-51110, 1247, 'float7'],
+            ],
+            [
+                [-10, '10', 'int'],
+                [10, None, 'float1'],
+                [1110.0, {}, 'float2'],
+                [-1110.0, "-11.9", 'float9'],
+                [-51110, 'int', 'float7'],
+            ],
+        ],
+        'val_type': [
+            [
+                [-10, 10, 'int'],
+                [10, 110, 'float1'],
+                [1110.0, 11011.9, 'float2'],
+                [1.0, 9.9, 'float3'],
+                [1.0, 2.9, 'float4'],
+                [1.0, 11.9, 'float5'],
+                [1.0, 9.9, 'float6'],
+                [1.0, 2.9, 'float7'],
+                [1.0, 11.9, 'float8'],
+                [-1110.0, -11.9, 'float9'],
+            ],
+            [
+                [-10, 10, 'int2'],
+                [10, 110, 'float0'],
+                [1110.0, 11011.9, 'float-'],
+                [1.0, 9.9, 'test'],
+                [1.0, 2.9, {}],
+                [1.0, 11.9, ''],
+                [1.0, 9.9, 42],
+                [1.0, 2.9, -42.42],
+                [1.0, 11.9, []],
+            ],
+        ],
+    },
+    #
+    ('attrgenfunct', 'n/a', 'generate_uniform_age'): {
+        'min_val': [
+            [[0, 120], [10, 100], [25.0, 76.9], [55, 56], [55.0, 57.9]],
+            [[-1, 120], [210, 100], ['25.0', 76.9], [{}, 56], [-55.0, 57.9]],
+        ],
+        'max_val': [
+            [[0, 120], [10, 100], [25.0, 76.9], [55, 56], [55.0, 57.9]],
+            [[0, 140], [10, -100], [25.0, '76.9'], [55, {}], [55.0, -57.9]],
+        ],
+    },
+    #
+    ('attrgenfunct', 'n/a', 'generate_normal_value'): {
+        'mu': [
+            [
+                [1.0, 1.0, -10, 10, 'int'],
+                [-5, 25, -10, 110, 'float1'],
+                [100.42, 2000, -1110.0, 11011.9, 'float2'],
+                [24.24, 5.5, None, 30.0, 'float9'],
+                [24.24, 5.5, 10.0, None, 'float7'],
+            ],
+            [
+                ['1.0', 1.0, -10, 10, 'int'],
+                [-55, 25, -10, 110, 'float1'],
+                [255, 25, -10, 110, 'float1'],
+                [None, 2000, -1110.0, 11011.9, 'float2'],
+                [[], 5.5, None, 30.0, 'float9'],
+                [{}, 5.5, 10.0, None, 'float7'],
+            ],
+        ],
+        'sigma': [
+            [
+                [1.0, 1.0, -10, 10, 'int'],
+                [-5, 25, -10, 110, 'float1'],
+                [100.42, 2000, -1110.0, 11011.9, 'float2'],
+                [24.24, 5.5, None, 30.0, 'float9'],
+                [24.24, 5.5, 10.0, None, 'float7'],
+            ],
+            [
+                [1.0, '1.0', -10, 10, 'int'],
+                [-5, -25, -10, 110, 'float1'],
+                [100.42, None, -1110.0, 11011.9, 'float2'],
+                [24.24, {}, None, 30.0, 'float9'],
+                [24.24, [], 10.0, None, 'float7'],
+            ],
+        ],
+        'min_val': [
+            [
+                [1.0, 1.0, -10, 10, 'int'],
+                [-5, 25, -10, 110, 'float1'],
+                [100.42, 2000, -1110.0, 11011.9, 'float2'],
+                [24.24, 5.5, None, 30.0, 'float9'],
+                [24.24, 5.5, 10.0, None, 'float7'],
+            ],
+            [
+                [1.0, 1.0, '-10', 10, 'int'],
+                [-5, 25, 120, 110, 'float1'],
+                [100.42, 2000, {}, 11011.9, 'float2'],
+                [24.24, 5.5, 'None', 30.0, 'float9'],
+                [24.24, 5.5, 120.0, None, 'float7'],
+            ],
+        ],
+        'max_val': [
+            [
+                [1.0, 1.0, -10, 10, 'int'],
+                [-5, 25, -10, 110, 'float1'],
+                [100.42, 2000, -1110.0, 11011.9, 'float2'],
+                [24.24, 5.5, None, 30.0, 'float9'],
+                [24.24, 5.5, 10.0, None, 'float7'],
+            ],
+            [
+                [1.0, 1.0, -10, '10', 'int'],
+                [-5, 25, -10, -110, 'float1'],
+                [100.42, 2000, -1110.0, {}, 'float2'],
+                [24.24, 5.5, None, -30.0, 'float9'],
+                [24.24, 5.5, 10.0, [], 'float7'],
+            ],
+        ],
+        'val_type': [
+            [
+                [1.0, 1.0, -10, 10, 'int'],
+                [-5, 25, -10, 110, 'float1'],
+                [100.42, 2000, -1110.0, 11011.9, 'float2'],
+                [24.24, 5.5, None, 30.0, 'float9'],
+                [24.24, 5.5, 10.0, None, 'float7'],
+            ],
+            [
+                [1.0, 1.0, -10, 10, 'int2'],
+                [-5, 25, -10, 110, 'float21'],
+                [100.42, 2000, -1110.0, 11011.9, None],
+                [24.24, 5.5, None, 30.0, 42.42],
+                [24.24, 5.5, 10.0, None, {}],
+            ],
+        ],
+    },
+    #
+    ('attrgenfunct', 'n/a', 'generate_normal_age'): {
+        'mu': [
+            [
+                [51.0, 1.0, 0, 110],
+                [45, 25, 4, 110],
+                [50.42, 50, 5, 77],
+                [24.24, 5.5, 1, 50.0],
+                [24.24, 5.5, 10.0, 99],
+            ],
+            [
+                ['51.0', 1.0, 0, 110],
+                [-45, 25, 4, 110],
+                [223, 25, 4, 110],
+                [None, 50, 5, 77],
+                [30, 20, 40, 110],
+                [70, 20, 10, 60],
+                [{}, 5.5, 1, 50.0],
+                ['', 5.5, 10.0, 99],
+            ],
+        ],
+        'sigma': [
+            [
+                [51.0, 1.0, 0, 110],
+                [45, 25, 4, 110],
+                [50.42, 50, 5, 77],
+                [24.24, 5.5, 1, 50.0],
+                [24.24, 5.5, 10.0, 99],
+            ],
+            [
+                [51.0, -1.0, 0, 110],
+                [45, '25', 4, 110],
+                [50.42, None, 5, 77],
+                [24.24, {}, 1, 50.0],
+                [24.24, [], 10.0, 99],
+            ],
+        ],
+        'min_val': [
+            [
+                [51.0, 1.0, 0, 110],
+                [45, 25, 4, 110],
+                [50.42, 50, 5, 77],
+                [24.24, 5.5, 1, 50.0],
+                [24.24, 5.5, 10.0, 99],
+            ],
+            [
+                [51.0, 1.0, -10, 110],
+                [45, 25, 134, 110],
+                [50.42, 50, 'None', 77],
+                [24.24, 5.5, {}, 50.0],
+                [24.24, 5.5, [], 99],
+            ],
+        ],
+        'max_val': [
+            [
+                [51.0, 1.0, 0, 110],
+                [45, 25, 4, 110],
+                [50.42, 50, 5, 77],
+                [24.24, 5.5, 1, 50.0],
+                [24.24, 5.5, 10.0, 99],
+            ],
+            [
+                [51.0, 1.0, 0, '110'],
+                [45, 25, 4, -110],
+                [50.42, 50, 5, 'None'],
+                [24.24, 5.5, 1, {}],
+                [24.24, 5.5, 10.0, []],
+            ],
+        ],
+    },
+    # add tests for generate_normal_value, generate_normal_age
+}
+
+# =============================================================================
+
+
+class TestCase(unittest.TestCase):
+
+    # Initialise test case  - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def setUp(self):
+        pass  # Nothing to initialize
+
+    # Clean up test case  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def tearDown(self):
+        pass  # Nothing to clean up
+
+    # ---------------------------------------------------------------------------
+    # Start test cases
+
+    def testArguments(self, test_data):
+        """Test if a function or method can be called or initialised correctly with
+        different values for their input arguments (parameters).
+
+        The argument 'test_data' must be a dictionary with the following
+        structure:
+
+        - Keys are tuples consisting of three strings:
+          (module_name, class_name, function_or_method_name)
+        - Values are dictionaries where the keys are the names of the input
+          argument that is being tested, and the values of these dictionaries
+          are a list that contains two lists. The first list contains valid
+          input arguments ('normal' argument tests) that should pass the test,
+          while the second list contains illegal input arguments ('exception'
+          argument tests) that should raise an exception.
+
+          The lists of test cases are itself lists, each containing a number of
+          input argument values, as many as are expected by the function or
+          method that is being tested.
+
+        This function returns a list containing the test results, where each
+        list element is a string with comma separated values (CSV) which are to
+        be written into the testing log file.
+        """
+
+        test_res_list = []  # The test results, one element per element in the test
+        # data dictionary
+
+        for (test_method_names, test_method_data) in test_data.iteritems():
+            test_method_name = test_method_names[2]
+            print('Testing arguments for method/function:', test_method_name)
+
+            for argument_name in test_method_data:
+                print('  Testing input argument:', argument_name)
+
+                norm_test_data = test_method_data[argument_name][0]
+                exce_test_data = test_method_data[argument_name][1]
+                print('    Normal test cases:   ', norm_test_data)
+                print('    Exception test cases:', exce_test_data)
+
+                # Conduct normal tests - - - - - - - - - - - - - - - - - - - - - - - -
+                #
+                num_norm_test_cases = len(norm_test_data)
+                num_norm_test_passed = 0
+                num_norm_test_failed = 0
+                norm_failed_desc_str = ''
+
+                for test_input in norm_test_data:
+                    passed = True  # Assume the test will pass :-)
+
+                    if len(test_input) == 0:  # Method has no input argument
+                        try:
+                            getattr(attrgenfunct, test_method_name)()
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 1:  # Method has one input argument
+                        try:
+                            getattr(attrgenfunct, test_method_name)(test_input[0])
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 2:  # Method has two input arguments
+                        try:
+                            getattr(attrgenfunct, test_method_name)(
+                                test_input[0], test_input[1]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 3:  # Method has three input arguments
+                        try:
+                            getattr(attrgenfunct, test_method_name)(
+                                test_input[0], test_input[1], test_input[2]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 4:  # Method has four input arguments
+                        try:
+                            getattr(attrgenfunct, test_method_name)(
+                                test_input[0], test_input[1], test_input[2], test_input[3]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 5:  # Method has five input arguments
+                        try:
+                            getattr(attrgenfunct, test_method_name)(
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                                test_input[4],
+                            )
+                        except:
+                            passed = False
+
+                    else:
+                        raise Exception('Illegal number of input arguments')
+
+                    # Now process test results
+                    #
+                    if passed == False:
+                        num_norm_test_failed += 1
+                        norm_failed_desc_str += 'Failed test for input ' + "'%s'; " % (
+                            str(test_input)
+                        )
+                    else:
+                        num_norm_test_passed += 1
+
+                assert num_norm_test_failed + num_norm_test_passed == num_norm_test_cases
+
+                norm_test_result_str = (
+                    test_method_names[0]
+                    + ','
+                    + test_method_names[1]
+                    + ','
+                    + test_method_names[2]
+                    + ','
+                    + argument_name
+                    + ',normal,'
+                    + '%d,' % (num_norm_test_cases)
+                )
+                if num_norm_test_failed == 0:
+                    norm_test_result_str += 'all tests passed'
+                else:
+                    norm_test_result_str += '%d tests failed,' % (num_norm_test_failed)
+                    norm_test_result_str += '"' + norm_failed_desc_str[:-2] + '"'
+
+                test_res_list.append(norm_test_result_str)
+
+                # Conduct exception tests - - - - - - - - - - - - - - - - - - - - - - -
+                #
+                num_exce_test_cases = len(exce_test_data)
+                num_exce_test_passed = 0
+                num_exce_test_failed = 0
+                exce_failed_desc_str = ''
+
+                for test_input in exce_test_data:
+                    passed = True  # Assume the test will pass (i.e. raise an exception)
+
+                    if len(test_input) == 0:  # Method has no input argument
+                        try:
+                            self.assertRaises(
+                                Exception, getattr(attrgenfunct, test_method_name)
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 1:  # Method has one input argument
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(attrgenfunct, test_method_name),
+                                test_input[0],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 2:  # Method has two input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(attrgenfunct, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 3:  # Method has three input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(attrgenfunct, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 4:  # Method has four input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(attrgenfunct, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 5:  # Method has five input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(attrgenfunct, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                                test_input[4],
+                            )
+                        except:
+                            passed = False
+
+                    else:
+                        raise Exception('Illegal number of input arguments')
+
+                    # Now process test results
+                    #
+                    if passed == False:
+                        num_exce_test_failed += 1
+                        exce_failed_desc_str += 'Failed test for input ' + "'%s'; " % (
+                            str(test_input)
+                        )
+                    else:
+                        num_exce_test_passed += 1
+
+                assert num_exce_test_failed + num_exce_test_passed == num_exce_test_cases
+
+                exce_test_result_str = (
+                    test_method_names[0]
+                    + ','
+                    + test_method_names[1]
+                    + ','
+                    + test_method_names[2]
+                    + ','
+                    + argument_name
+                    + ',exception,'
+                    + '%d,' % (num_exce_test_cases)
+                )
+                if num_exce_test_failed == 0:
+                    exce_test_result_str += 'all tests passed'
+                else:
+                    exce_test_result_str += '%d tests failed,' % (num_exce_test_failed)
+                    exce_test_result_str += '"' + exce_failed_desc_str[:-2] + '"'
+
+                test_res_list.append(exce_test_result_str)
+
+            test_res_list.append('')  # Empty line between tests of methods
+
+        return test_res_list
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_phone_number_australia(self, num_tests):
+        """Test the functionality of 'generate_phone_number_australia', making
+        sure this function returns strings of consisting only of digits, with
+        the first digit being 0, and two whitespaces at specific positions.
+        """
+
+        print('Testing functionality of "generate_phone_number_australia"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            oz_phone_num = attrgenfunct.generate_phone_number_australia()
+
+            passed = True
+
+            if len(oz_phone_num) != 12:
+                passed = False
+            if oz_phone_num[0] != '0':
+                passed = False
+            if oz_phone_num[2] != ' ':
+                passed = False
+            if oz_phone_num[7] != ' ':
+                passed = False
+            oz_phone_num_no_space = oz_phone_num.replace(' ', '')  # Remove spaces
+            if not oz_phone_num_no_space.isdigit():
+                passed = False
+
+            if passed == True:
+                num_passed += 1
+            else:
+                num_failed += 1
+
+        assert num_passed + num_failed == num_tests
+
+        test_result_str = (
+            'attrgenfunct,n/a,generate_phone_number_australia,'
+            + 'n/a,funct,%d,' % (num_tests)
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_credit_card_number(self, num_tests):
+        """Test the functionality of 'generate_credit_card_number', making sure
+        this function returns strings of consisting only of four groups of
+        digits, eac hwith 4 digits, and three whitespaces at specific positions.
+        """
+
+        print('Testing functionality of "generate_credit_card_number"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            cc_num = attrgenfunct.generate_credit_card_number()
+
+            passed = True
+
+            if len(cc_num) != 19:
+                passed = False
+            if cc_num[4] != ' ':
+                passed = False
+            if cc_num[9] != ' ':
+                passed = False
+            if cc_num[14] != ' ':
+                passed = False
+            cc_num_no_space = cc_num.replace(' ', '')  # Remove spaces
+            if not cc_num_no_space.isdigit():
+                passed = False
+
+            if passed == True:
+                num_passed += 1
+            else:
+                num_failed += 1
+
+        assert num_passed + num_failed == num_tests
+
+        test_result_str = (
+            'attrgenfunct,n/a,generate_credit_card_number,' + 'n/a,funct,%d,' % (num_tests)
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_uniform_value(self, num_tests):
+        """Test the functionality of 'generate_uniform_value', making sure
+        this function returns a string according to the given value type in
+        the range between the minimum and maximum value specified.
+        """
+
+        print('Testing functionality of "generate_uniform_value"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            for val_type in [
+                'int',
+                'float1',
+                'float2',
+                'float3',
+                'float4',
+                'float5',
+                'float6',
+                'float7',
+                'float8',
+                'float9',
+            ]:
+
+                for min_val in [-100.0, -42, 0, 10, 100.0]:
+                    for max_val in [200.0, 242, 10000.01]:
+
+                        norm_val = attrgenfunct.generate_uniform_value(
+                            min_val, max_val, val_type
+                        )
+                        passed = True
+
+                        if float(norm_val) < min_val:
+                            passed = False
+                        if float(norm_val) > max_val:
+                            passed = False
+                        if (val_type == 'int') and ('.' in norm_val):
+                            passed = False
+                        if val_type != 'int':
+                            num_digit = int(val_type[-1])
+                            norm_val_list = norm_val.split('.')
+                            if len(norm_val_list[1]) > num_digit:
+                                passed = (
+                                    False  # Only larger, because for example 100.0 will
+                                )
+                                # only return with 1 digit after comma
+
+                        if passed == True:
+                            num_passed += 1
+                        else:
+                            num_failed += 1
+
+        assert num_passed + num_failed == (15 * 10 * num_tests)
+
+        test_result_str = 'attrgenfunct,n/a,generate_uniform_value,' + 'n/a,funct,%d,' % (
+            15 * 10 * num_tests
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_uniform_age(self, num_tests):
+        """Test the functionality of 'generate_uniform_age', making sure this
+        function returns a string with an integer value between 0 and 130.
+        """
+
+        print('Testing functionality of "generate_uniform_age"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            for (min_val, max_val) in [(0, 10), (0, 120), (0, 45), (42, 48), (40, 120)]:
+
+                age_val = attrgenfunct.generate_uniform_age(min_val, max_val)
+
+                passed = True
+
+                if float(age_val) < min_val:
+                    passed = False
+                if float(age_val) > max_val:
+                    passed = False
+                if '.' in age_val:
+                    passed = False
+
+                if passed == True:
+                    num_passed += 1
+                else:
+                    num_failed += 1
+
+        assert num_passed + num_failed == num_tests * 5
+
+        test_result_str = 'attrgenfunct,n/a,generate_uniform_age,' + 'n/a,funct,%d,' % (
+            num_tests * 5
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_normal_value(self, num_tests):
+        """Test the functionality of 'generate_normal_value', making sure this
+        function returns a string according to the given value type in the
+        range between the minimum and maximum value specified.
+        """
+
+        print('Testing functionality of "generate_normal_value"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            for val_type in [
+                'int',
+                'float1',
+                'float2',
+                'float3',
+                'float4',
+                'float5',
+                'float6',
+                'float7',
+                'float8',
+                'float9',
+            ]:
+
+                for (mu, sigma, min_val, max_val) in [
+                    (0, 1, -10, 10),
+                    (0, 1, -1, 1),
+                    (-100.5, 123.45, -1010.7, -10.11),
+                    (12345.87, 54875.1, -400532, 96344),
+                    (0, 1, None, 10),
+                    (0, 1, None, 1),
+                    (-100.5, 123.45, None, -10.11),
+                    (12345.87, 54875.1, None, 96344),
+                    (0, 1, -10, None),
+                    (0, 1, -1, None),
+                    (-100.5, 123.45, -1010.7, None),
+                    (12345.87, 54875.1, -400532, None),
+                    (0, 1, None, None),
+                    (0, 1, None, None),
+                    (-100.5, 123.45, None, None),
+                    (12345.87, 54875.1, None, None),
+                ]:
+
+                    norm_val = attrgenfunct.generate_normal_value(
+                        mu, sigma, min_val, max_val, val_type
+                    )
+                    passed = True
+
+                    if (min_val != None) and (float(norm_val) < min_val):
+                        print('1:', norm_val, min_val)
+                        passed = False
+                    if (max_val != None) and (float(norm_val) > max_val):
+                        print('2:', norm_val, max_val)
+                        passed = False
+                    if (val_type == 'int') and ('.' in norm_val):
+                        print('3:', norm_val)
+                        passed = False
+                    if val_type != 'int':
+                        num_digit = int(val_type[-1])
+                        norm_val_list = norm_val.split('.')
+
+                        if len(norm_val_list[1]) > num_digit:
+                            print('4:', norm_val, val_type)
+                            passed = False  # Only larger, because for example 100.0 will
+                            # only return with 1 digit after comma
+
+                    if passed == True:
+                        num_passed += 1
+                    else:
+                        num_failed += 1
+
+        assert num_passed + num_failed == (16 * 10 * num_tests)
+
+        test_result_str = 'attrgenfunct,n/a,generate_normal_value,' + 'n/a,funct,%d,' % (
+            16 * 10 * num_tests
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_generate_normal_age(self, num_tests):
+        """Test the functionality of 'generate_normal_age', making sure this
+        function returns a string with an integer value between 0 and 130.
+        """
+
+        print('Testing functionality of "generate_normal_age"')
+
+        num_passed = 0
+        num_failed = 0
+
+        for i in range(num_tests):
+
+            for (mu, sigma, min_val, max_val) in [
+                (50, 100, 0, 130),
+                (25, 20, 5, 55),
+                (65, 10, 60, 130),
+                (85, 20, 0, 95),
+            ]:
+
+                age_val = attrgenfunct.generate_normal_age(mu, sigma, min_val, max_val)
+
+                passed = True
+
+                if float(age_val) < min_val:
+                    passed = False
+                if float(age_val) > max_val:
+                    passed = False
+                if '.' in age_val:
+                    passed = False
+
+                if passed == True:
+                    num_passed += 1
+                else:
+                    num_failed += 1
+
+        assert num_passed + num_failed == num_tests * 4
+
+        test_result_str = 'attrgenfunct,n/a,generate_normal_age,' + 'n/a,funct,%d,' % (
+            num_tests * 4
+        )
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed' % (num_failed)
+
+        return [test_result_str, '']
+
+
+# =============================================================================
+# Generate a time string to be used for the log file
+#
+curr_time_tuple = time.localtime()
+curr_time_str = (
+    str(curr_time_tuple[0])
+    + str(curr_time_tuple[1]).zfill(2)
+    + str(curr_time_tuple[2]).zfill(2)
+    + '-'
+    + str(curr_time_tuple[3]).zfill(2)
+    + str(curr_time_tuple[4]).zfill(2)
+)
+
+# Write test output header line into the log file
+#
+out_file_name = './logs/attrgenfunctTest-%s.csv' % (curr_time_str)
+
+out_file = open(out_file_name, 'w')
+
+out_file.write('Test results generated by attrgenfunctTest.py' + os.linesep)
+
+out_file.write('Test started: ' + curr_time_str + os.linesep)
+
+out_file.write(os.linesep)
+
+out_file.write(
+    'Module name,Class name,Method name,Arguments,Test_type,'
+    + 'Patterns tested,Summary,Failure description'
+    + os.linesep
+)
+out_file.write(os.linesep)
+
+# Create instances for the testcase class that calls all tests
+#
+test_res_list = []
+test_case_ins = TestCase('testArguments')
+test_res_list += test_case_ins.testArguments(test_argument_data_dict)
+
+test_case_ins = TestCase('testFunct_generate_phone_number_australia')
+test_res_list += test_case_ins.testFunct_generate_phone_number_australia(num_tests)
+
+test_case_ins = TestCase('testFunct_generate_credit_card_number')
+test_res_list += test_case_ins.testFunct_generate_credit_card_number(num_tests)
+
+test_case_ins = TestCase('testFunct_generate_uniform_value')
+test_res_list += test_case_ins.testFunct_generate_uniform_value(num_tests)
+
+test_case_ins = TestCase('testFunct_generate_uniform_age')
+test_res_list += test_case_ins.testFunct_generate_uniform_age(num_tests)
+
+test_case_ins = TestCase('testFunct_generate_normal_value')
+test_res_list += test_case_ins.testFunct_generate_normal_value(num_tests)
+
+test_case_ins = TestCase('testFunct_generate_normal_age')
+test_res_list += test_case_ins.testFunct_generate_normal_age(num_tests)
+
+# Write test output results into the log file
+#
+for line in test_res_list:
+    out_file.write(line + os.linesep)
+
+out_file.close()
+
+print('Test results are written to', out_file_name)
+
+for line in test_res_list:
+    print(line)

tests/basefunctions_test.py

@@ -0,0 +1,1475 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+import random
+from pathlib import Path
+
+random.seed(42)
+import time
+import unittest
+
+from geco_data_generator import basefunctions
+
+
+def f1(x):
+    print(x)
+
+
+def f2():
+    print('hello')
+
+
+# Define argument test cases here
+#
+test_argument_data_dict = {
+    ('basefunctions', 'n/a', 'check_is_not_none'): {
+        'variable': [
+            [['testArgument', 'test'], ['hello', 'test'], ['1.0', 'test']],
+            [
+                [None, 'test'],
+                ['', 'test'],
+                [123, 'test'],
+                [0.234, 'test'],
+                [{}, 'test'],
+                [[], 'test'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', 'hello'],
+                ['testArgument', 123],
+                ['testArgument', 0.234],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+            [['testArgument', None]],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_string'): {
+        'variable': [
+            [['testArgument', 'hello'], ['test', 'hello'], ['1.0', 'hello']],
+            [
+                [None, 'hello'],
+                ['', 'hello'],
+                [123, 'hello'],
+                [0.234, 'hello'],
+                [{}, 'hello'],
+                [[], 'hello'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', 'hello'],
+                ['testArgument', ''],
+                ['testArgument', '123'],
+                ['testArgument', '-1.23'],
+                ['testArgument', "'!?!'"],
+                ['testArgument', "HELlo"],
+                ['testArgument', "[..]"],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 123],
+                ['testArgument', 1.87],
+                ['testArgument', -75],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_unicode_string'): {
+        'variable': [
+            [['testArgument', u'hello'], ['test', u'hello'], ['1.0', u'hello']],
+            [
+                [None, u'hello'],
+                ['', u'hello'],
+                [123, u'hello'],
+                [0.234, u'hello'],
+                [{}, u'hello'],
+                [[], u'hello'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', u'hello'],
+                ['testArgument', u'text'],
+                ['testArgument', u''],
+                ['testArgument', u'123'],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', ''],
+                ['testArgument', -123],
+                ['testArgument', 123],
+                ['testArgument', 1.87],
+                ['testArgument', 'ascii'],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_string_or_unicode_string'): {
+        'variable': [
+            [
+                ['testArgument', 'hello'],
+                ['test', u'hello'],
+                ['1.0', 'hello2'],
+                ['1.0', u'hello'],
+            ],
+            [
+                [None, u'hello'],
+                ['', 'hello'],
+                [123, u'hello'],
+                [0.234, 'hello'],
+                [{}, u'hello'],
+                [[], u'hello'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', u'hello'],
+                ['testArgument', 'text'],
+                ['testArgument', u''],
+                ['testArgument', u'123'],
+                ['testArgument', ''],
+                ['testArgument', '123'],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 123.45],
+                ['testArgument', -123],
+                ['testArgument', -123.65],
+                ['testArgument', {}],
+                ['testArgument', []],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_non_empty_string'): {
+        'variable': [
+            [['testArgument', 'hello'], ['test', 'hello'], ['1.0', 'hello']],
+            [
+                [None, 'hello'],
+                ['', 'hello'],
+                [123, 'hello'],
+                [0.234, 'hello'],
+                [{}, 'hello'],
+                [[], 'hello'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', 'hello'],
+                ['testArgument', '123'],
+                ['testArgument', '-1.23'],
+                ['testArgument', 'HELlo'],
+                ['testArgument', "'!?!'"],
+                ['testArgument', "[..]"],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 123],
+                ['testArgument', 1.87],
+                ['testArgument', -75],
+                ['testArgument', ''],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },  # , ['testArgument','hello']
+    ('basefunctions', 'n/a', 'check_is_number'): {
+        'variable': [
+            [['testArgument', 123], ['test', 123], ['1.0', 123]],
+            [[None, 123], ['', 123], [123, 123], [0.234, 123], [{}, 123], [[], 123]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0],
+                ['testArgument', -0],
+                ['testArgument', 1.23],
+                ['testArgument', -24.41],
+                ['testArgument', 1289837],
+                ['testArgument', -973293],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 'hello'],
+                ['testArgument', '123'],
+                ['testArgument', '[]'],
+                ['testArgument', '-123.34'],
+                ['testArgument', ''],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_positive'): {
+        'variable': [
+            [['testArgument', 1.0], ['test', 1.0], ['1.0', 1.0]],
+            [[None, 1.0], ['', 1.0], [123, 1.0], [0.234, 1.0], [{}, 1.0], [[], 1.0]],
+        ],
+        'value': [
+            [
+                ['testArgument', 1.0],
+                ['testArgument', 0.001],
+                ['testArgument', 0.0000001],
+                ['testArgument', 1],
+                ['testArgument', 1.474],
+                ['testArgument', 1236967],
+                ['testArgument', 17676.474],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -1.23],
+                ['testArgument', -123],
+                ['testArgument', -100000000],
+                ['testArgument', 'hello'],
+                ['testArgument', '123'],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_not_negative'): {
+        'variable': [
+            [['testArgument', 1.0], ['test', 1.0], ['1.0', 1.0]],
+            [[None, 1.0], ['', 1.0], [123, 1.0], [0.234, 1.0], [{}, 1.0], [[], 1.0]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0],
+                ['testArgument', -0],
+                ['testArgument', 1.0],
+                ['testArgument', 0.00],
+                ['testArgument', -0.000],
+                ['testArgument', 1],
+                ['testArgument', 1.474],
+                ['testArgument', 1236987],
+                ['testArgument', 17676.474],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -1.23],
+                ['testArgument', -123],
+                ['testArgument', -100000000],
+                ['testArgument', 'hello'],
+                ['testArgument', '123'],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_normalised'): {
+        'variable': [
+            [['testArgument', 1.0], ['test', 1.0], ['1.0', 1.0]],
+            [[None, 1.0], ['', 1.0], [123, 1.0], [0.234, 1.0], [{}, 1.0], [[], 1.0]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0],
+                ['testArgument', -0],
+                ['testArgument', 0.00],
+                ['testArgument', -0.0],
+                ['testArgument', 1],
+                ['testArgument', 1.0],
+                ['testArgument', 0.0001],
+                ['testArgument', 1.00000],
+                ['testArgument', 0.5],
+                ['testArgument', 0.9999],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -1.23],
+                ['testArgument', -123],
+                ['testArgument', 100],
+                ['testArgument', 1.0001],
+                ['testArgument', -1.0],
+                ['testArgument', 'hello'],
+                ['testArgument', '0.7'],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_percentage'): {
+        'variable': [
+            [['testArgument', 10.0], ['test', 10.0], ['1.0', 10.0]],
+            [[None, 10.0], ['', 10.0], [123, 10.0], [0.234, 10.0], [{}, 10.0], [[], 10.0]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0],
+                ['testArgument', -0],
+                ['testArgument', 0.00],
+                ['testArgument', -0.0],
+                ['testArgument', 1],
+                ['testArgument', 1.0],
+                ['testArgument', 0.0001],
+                ['testArgument', 99.000],
+                ['testArgument', 100],
+                ['testArgument', 0.5],
+                ['testArgument', 50],
+                ['testArgument', 50.001],
+                ['testArgument', 100.0],
+                ['testArgument', 0.9999],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -1.23],
+                ['testArgument', -123],
+                ['testArgument', 100.001],
+                ['testArgument', -0.0001],
+                ['testArgument', 'hello'],
+                ['testArgument', '85'],
+                ['testArgument', '45%'],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_integer'): {
+        'variable': [
+            [['testArgument', 10], ['test', 10], ['1.0', 10]],
+            [[None, 10], ['', 10], [123, 10], [0.234, 10], [{}, 10], [[], 10]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0],
+                ['testArgument', 1],
+                ['testArgument', 10],
+                ['testArgument', 1234],
+                ['testArgument', -1],
+                ['testArgument', -96234],
+                ['testArgument', -100],
+                ['testArgument', -0],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -1.23],
+                ['testArgument', 1.23],
+                ['testArgument', -0.0001],
+                ['testArgument', 0.001],
+                ['testArgument', 'hello'],
+                ['testArgument', '85'],
+                ['testArgument', 10000.0],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_float'): {
+        'variable': [
+            [['testArgument', 1.0], ['test', 1.0], ['1.0', 1.0]],
+            [[None, 1.0], ['', 1.0], [123, 1.0], [0.234, 1.0], [{}, 1.0], [[], 1.0]],
+        ],
+        'value': [
+            [
+                ['testArgument', 0.0],
+                ['testArgument', -0.0],
+                ['testArgument', 0.123],
+                ['testArgument', -65.9203],
+                ['testArgument', 42.123],
+                ['testArgument', -10000.0],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', -123],
+                ['testArgument', 123],
+                ['testArgument', 0],
+                ['testArgument', 100000],
+                ['testArgument', 'hello'],
+                ['testArgument', '8.5'],
+                ['testArgument', -0],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_dictionary'): {
+        'variable': [
+            [['testArgument', {}], ['test', {}], ['1.0', {}]],
+            [[None, {}], ['', {}], [123, {}], [0.234, {}], [{}, {}], [[], {}]],
+        ],
+        'value': [
+            [
+                ['testArgument', {}],
+                ['testArgument', {1: 2, 6: 0}],
+                ['testArgument', {'a': 4, 't': 1, (1, 4, 6): 'tr'}],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', "{1:2,3:4}"],
+                ['testArgument', []],
+                ['testArgument', set()],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_list'): {
+        'variable': [
+            [['testArgument', []], ['test', []], ['1.0', []]],
+            [[None, []], ['', []], [123, []], [0.234, []], [{}, []], [[], []]],
+        ],
+        'value': [
+            [
+                ['testArgument', []],
+                ['testArgument', [1, 3, 5]],
+                ['testArgument', [-1, -3, -5]],
+                ['testArgument', ['a', '56', 1, {}]],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', "[1,2,3,4]"],
+                ['testArgument', {}],
+                ['testArgument', set()],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_set'): {
+        'variable': [
+            [['testArgument', set()], ['test', set()], ['1.0', set()]],
+            [
+                [None, set()],
+                ['', set()],
+                [123, set()],
+                [0.234, set()],
+                [{}, set()],
+                [[], set()],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', set()],
+                ['testArgument', set([1, 2, 3])],
+                ['testArgument', set(['a', 'a'])],
+                ['testArgument', set(['a', '56', 1, 100.345])],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', "set([1,2,3])"],
+                ['testArgument', [1, 2, 3, 4]],
+                ['testArgument', {1: 2, 5: 6}],
+                ['testArgument', {}],
+                ['testArgument', []],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_tuple'): {
+        'variable': [
+            [['testArgument', ()], ['test', ()], ['1.0', ()]],
+            [[None, ()], ['', ()], [123, ()], [0.234, ()], [{}, ()], [[], ()]],
+        ],
+        'value': [
+            [
+                ['testArgument', ()],
+                ['testArgument', ('a', 'b')],
+                ['testArgument', (42, 'b')],
+                ['testArgument', (1, 100)],
+                ['testArgument', ('a', 'b', 'c', 1, 2, 3)],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', [1, 2, 3, 4]],
+                ['testArgument', {1: 2, 5: 6}],
+                ['testArgument', set([1, 2, 3])],
+                ['testArgument', "(1,2,3)"],
+                ['testArgument', []],
+                ['testArgument', {}],
+                ['testArgument', set()],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_is_flag'): {
+        'variable': [
+            [['testArgument', True], ['test', True], ['1.0', True]],
+            [[None, True], ['', True], [123, True], [0.234, True], [{}, True], [[], True]],
+        ],
+        'value': [
+            [
+                ['testArgument', True],
+                ['testArgument', False],
+                ['testArgument', 0],
+                ['testArgument', 1],
+                ['testArgument', 0.0],
+                ['testArgument', 1.0],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 'True'],
+                ['testArgument', 'False'],
+                ['testArgument', 0.01],
+                ['testArgument', 1.01],
+                ['testArgument', '1.0'],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'check_unicode_encoding_exists'): {
+        'unicode_encoding_string': [
+            [["ascii"], ["iso-8859-1"], ["ASCII"]],
+            [[None], ["asciii"], [123], ['']],
+        ]
+    },
+    ('basefunctions', 'n/a', 'check_is_function_or_method'): {
+        'variable': [
+            [['testArgument', f1], ['test', f1], ['1.0', f1]],
+            [[None, f1], ['', f1], [123, f1], [0.234, f1], [{}, f1], [[], f1]],
+        ],
+        'value': [
+            [
+                ['testArgument', f1],
+                ['testArgument', f2],
+                ['testArgument', basefunctions.check_is_not_none],
+                ['testArgument', basefunctions.check_is_function_or_method],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', 'f1'],
+                ['testArgument', 'f2'],
+                ['testArgument', 0.0],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'char_set_ascii'): {
+        'string_variable': [
+            [
+                ["hello"],
+                ["1256783"],
+                ["hello1234test5678"],
+                ["hello 1234 test 5678"],
+                [' 1 a 2 b '],
+            ],
+            [[None], [0.2345], [123], [[]], [{}], [-5434.6]],
+        ]
+    },
+    ('basefunctions', 'n/a', 'check_is_valid_format_str'): {
+        'variable': [
+            [['testArgument', 'int'], ['test', 'int'], ['1.0', 'int']],
+            [
+                [None, 'int'],
+                ['', 'int'],
+                [123, 'int'],
+                [0.234, 'int'],
+                [{}, 'int'],
+                [[], 'int'],
+            ],
+        ],
+        'value': [
+            [
+                ['testArgument', 'int'],
+                ['testArgument', 'float1'],
+                ['testArgument', 'float2'],
+                ['testArgument', 'float3'],
+                ['testArgument', 'float4'],
+                ['testArgument', 'float5'],
+                ['testArgument', 'float6'],
+                ['testArgument', 'float7'],
+                ['testArgument', 'float8'],
+                ['testArgument', 'float9'],
+            ],
+            [
+                ['testArgument', None],
+                ['testArgument', ''],
+                ['testArgument', 'float10'],
+                ['testArgument', 'int1'],
+                ['testArgument', 'floet1'],
+                ['testArgument', 1],
+                ['testArgument', []],
+                ['testArgument', {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'float_to_str'): {
+        'number_variable': [
+            [
+                [1234, 'int'],
+                [123.4, 'int'],
+                [1.0004, 'int'],
+                [1000000000, 'int'],
+                [-12345.678, 'int'],
+            ],
+            [
+                [None, 'int'],
+                ['', 'int'],
+                ['123', 'int'],
+                ['456.98', 'int'],
+                [{}, 'int'],
+                [[], 'int'],
+            ],
+        ],
+        'format_string': [
+            [
+                [100, 'int'],
+                [100, 'float1'],
+                [100, 'float2'],
+                [100, 'float3'],
+                [100, 'float4'],
+                [100, 'float5'],
+                [100, 'float6'],
+                [100, 'float7'],
+                [100, 'float8'],
+                [100, 'float9'],
+            ],
+            [
+                [100, None],
+                [100, ''],
+                [100, 'float10'],
+                [100, 'int1'],
+                [100, 'floet1'],
+                [100, 1],
+                [100, []],
+                [100, {}],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'str2comma_separated_list'): {
+        'string_variable': [
+            [
+                [u"ab,cd,ef"],
+                [u"12,567,83"],
+                [u"hello,1234,test,5678"],
+                [u"hello ,1234 ,test ,5678"],
+                [u' 1 a, 2 b '],
+                [u'as$,bc#'],
+                [u'abcdef'],
+                [u' , '],
+            ],
+            [[None], [0.2345], [123], [''], [], {}],
+        ]
+    },
+    ('basefunctions', 'n/a', 'read_csv_file'): {
+        'file_name': [
+            [
+                ['test1.csv', "ascii", False],  # Assume these test files exist
+                ['test3.csv', "ascii", False],
+                ['test2.txt', "ascii", False],
+            ],
+            [
+                [None, "ascii", False],
+                ['', "ascii", False],
+                ['test3.csvv', "ascii", False],
+                [234, "ascii", False],
+                [{}, "ascii", False],
+                [[], "ascii", False],
+            ],
+        ],
+        'encoding': [
+            [
+                ['test1.csv', "ascii", False],
+                ['test1.csv', "iso-8859-1", False],
+                ['test1.csv', "ASCII", False],
+                ['test1.csv', None, False],
+            ],
+            [
+                ['test1.csv', '', False],
+                ['test1.csv', 'asciii', False],
+                ['test1.csv', 'ascii encode', False],
+                ['test1.csv', 123, False],
+                ['test1.csv', [], False],
+                ['test1.csv', {}, False],
+            ],
+        ],
+        'header_line': [
+            [
+                ['test1.csv', "ascii", True],
+                ['test1.csv', "ascii", False],
+                ['test1.csv', "ascii", 1.0],
+                ['test1.csv', "ascii", 1],
+                ['test1.csv', "ascii", 0],
+                ['test1.csv', "ascii", 0.0],
+            ],
+            [
+                ['test1.csv', "ascii", None],
+                ['test1.csv', "ascii", 'True'],
+                ['test1.csv', "ascii", '1.0'],
+                ['test1.csv', "ascii", 1.01],
+                ['test1.csv', "ascii", 0.01],
+                ['test1.csv', "ascii", ''],
+            ],
+        ],
+    },
+    ('basefunctions', 'n/a', 'write_csv_file'): {
+        'file_name': [
+            [
+                ['test.csv', "ascii", None, []],
+                ['test.csv', "ascii", None, []],
+                ['test.txt', "ascii", None, []],
+                ['test.csv', "ascii", None, []],
+            ],
+            [
+                [None, "ascii", None, []],
+                ['', "ascii", None, []],
+                ['test-3/csvv', "ascii", None, []],
+                [234, "ascii", None, []],
+                [{}, "ascii", None, []],
+                [[], "ascii", None, []],
+            ],
+        ],
+        'encoding': [
+            [
+                ['test.csv', "ascii", None, []],
+                ['test.csv', "iso-8859-1", None, []],
+                ['test.csv', "ASCII", None, []],
+                ['test.csv', None, None, []],
+            ],
+            [
+                ['test.csv', '', None, []],
+                ['test.csv', 'asciii', None, []],
+                ['test.csv', 'ascii encode', None, []],
+                ['test.csv', 123, None, []],
+                ['test.csv', [], None, []],
+                ['test.csv', {}, None, []],
+            ],
+        ],
+        'header_list': [
+            [
+                ['test.csv', "ascii", None, []],
+                ['test.csv', "ascii", [], []],
+                ['test.csv', "ascii", ['attr1'], []],
+                ['test.csv', "ascii", ['attr1', 'attr2'], []],
+                ['test.csv', "ascii", [' attr1 '], []],
+                ['test.csv', "ascii", [''], []],
+            ],
+            [
+                ['test.csv', "ascii", '', []],
+                ['test.csv', "ascii", 'attr1', []],
+                ['test.csv', "ascii", 'attr1,attr2', []],
+                ['test.csv', "ascii", 1, []],
+                ['test.csv', "ascii", set(['attr1']), []],
+                ['test.csv', "ascii", {1: 'attr1'}, []],
+            ],
+        ],
+        'file_data': [
+            [
+                ['test.csv', "ascii", None, []],
+                ['test.csv', "ascii", None, [['test']]],
+                [
+                    'test.csv',
+                    "ascii",
+                    None,
+                    [['1'], ['2'], ['3', '4'], ['5', '6', '7'], ['8,9,10']],
+                ],
+                ['test.csv', "ascii", None, [['a', 'b'], ['c', 'd', 'e']]],
+                [
+                    'test.csv',
+                    "ascii",
+                    None,
+                    [['a'], ['1', '2'], ['b', '$%'], ['', '10.34']],
+                ],
+                ['test.csv', "ascii", None, [['']]],
+            ],
+            [
+                ['test.csv', "ascii", None, None],
+                ['test.csv', "ascii", None, 'test'],
+                ['test.csv', "ascii", None, ['test']],
+                ['test.csv', "ascii", None, [[1, 2], [3, 4]]],
+                ['test.csv', "ascii", None, {}],
+                ['test.csv', "ascii", None, set()],
+                ['test.csv', "ascii", None, ''],
+            ],
+        ],
+    },
+}
+
+# =============================================================================
+
+
+class TestCase(unittest.TestCase):
+
+    # Initialise test case  - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def setUp(self):
+        pass  # Nothing to initialize
+
+    # Clean up test case  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def tearDown(self):
+        pass  # Nothing to clean up
+
+    # ---------------------------------------------------------------------------
+    # Start test cases
+
+    def testArguments(self, test_data):
+        """Test if a function or method can be called or initialised correctly with
+        different values for their input arguments (parameters).
+
+        The argument 'test_data' must be a dictionary with the following
+        structure:
+
+        - Keys are tuples consisting of three strings:
+          (module_name, class_name, function_or_method_name)
+        - Values are dictionaries where the keys are the names of the input
+          argument that is being tested, and the values of these dictionaries
+          are a list that contains two lists. The first list contains valid
+          input arguments ('normal' argument tests) that should pass the test,
+          while the second list contains illegal input arguments ('exception'
+          argument tests) that should raise an exception.
+
+          The lists of test cases are itself lists, each containing a number of
+          input argument values, as many as are expected by the function or
+          method that is being tested.
+
+        This function returns a list containing the test results, where each
+        list element is a string with comma separated values (CSV) which are to
+        be written into the testing log file.
+        """
+
+        test_res_list = []  # The test results, one element per element in the test
+        # data dictionary
+
+        for test_method_names, test_method_data in test_data.items():
+            test_method_name = test_method_names[2]
+            print('Testing arguments for method/function:', test_method_name)
+
+            for argument_name in test_method_data:
+                print('  Testing input argument:', argument_name)
+
+                norm_test_data = test_method_data[argument_name][0]
+                exce_test_data = test_method_data[argument_name][1]
+                print('    Normal test cases:   ', norm_test_data)
+                print('    Exception test cases:', exce_test_data)
+
+                # Conduct normal tests - - - - - - - - - - - - - - - - - - - - - - - -
+                #
+                num_norm_test_cases = len(norm_test_data)
+                num_norm_test_passed = 0
+                num_norm_test_failed = 0
+                norm_failed_desc_str = ''
+
+                for test_input in norm_test_data:
+                    passed = True  # Assume the test will pass :-)
+
+                    if len(test_input) == 0:  # Method has no input argument
+                        try:
+                            getattr(basefunctions, test_method_name)()
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 1:  # Method has one input argument
+                        try:
+                            getattr(basefunctions, test_method_name)(test_input[0])
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 2:  # Method has two input arguments
+                        try:
+                            getattr(basefunctions, test_method_name)(
+                                test_input[0], test_input[1]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 3:  # Method has three input arguments
+                        try:
+                            getattr(basefunctions, test_method_name)(
+                                test_input[0], test_input[1], test_input[2]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 4:  # Method has four input arguments
+                        try:
+                            getattr(basefunctions, test_method_name)(
+                                test_input[0], test_input[1], test_input[2], test_input[3]
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 5:  # Method has five input arguments
+                        try:
+                            getattr(basefunctions, test_method_name)(
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                                test_input[4],
+                            )
+                        except:
+                            passed = False
+
+                    else:
+                        raise Exception('Illegal number of input arguments')
+
+                    # Now process test results
+                    #
+                    if passed == False:
+                        num_norm_test_failed += 1
+                        norm_failed_desc_str += 'Failed test for input ' + "'%s'; " % (
+                            str(test_input)
+                        )
+                    else:
+                        num_norm_test_passed += 1
+
+                assert num_norm_test_failed + num_norm_test_passed == num_norm_test_cases
+
+                norm_test_result_str = (
+                    test_method_names[0]
+                    + ','
+                    + test_method_names[1]
+                    + ','
+                    + test_method_names[2]
+                    + ','
+                    + argument_name
+                    + ',normal,'
+                    + '%d,' % (num_norm_test_cases)
+                )
+                if num_norm_test_failed == 0:
+                    norm_test_result_str += 'all tests passed'
+                else:
+                    norm_test_result_str += '%d tests failed,' % (num_norm_test_failed)
+                    norm_test_result_str += '"' + norm_failed_desc_str[:-2] + '"'
+
+                test_res_list.append(norm_test_result_str)
+
+                # Conduct exception tests - - - - - - - - - - - - - - - - - - - - - - -
+                #
+                num_exce_test_cases = len(exce_test_data)
+                num_exce_test_passed = 0
+                num_exce_test_failed = 0
+                exce_failed_desc_str = ''
+
+                for test_input in exce_test_data:
+                    passed = True  # Assume the test will pass (i.e. raise an exception)
+
+                    if len(test_input) == 0:  # Method has no input argument
+                        try:
+                            self.assertRaises(
+                                Exception, getattr(basefunctions, test_method_name)
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 1:  # Method has one input argument
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(basefunctions, test_method_name),
+                                test_input[0],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 2:  # Method has two input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(basefunctions, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 3:  # Method has three input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(basefunctions, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 4:  # Method has four input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(basefunctions, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                            )
+                        except:
+                            passed = False
+
+                    elif len(test_input) == 5:  # Method has five input arguments
+                        try:
+                            self.assertRaises(
+                                Exception,
+                                getattr(basefunctions, test_method_name),
+                                test_input[0],
+                                test_input[1],
+                                test_input[2],
+                                test_input[3],
+                                test_input[4],
+                            )
+                        except:
+                            passed = False
+
+                    else:
+                        raise Exception('Illegal number of input arguments')
+
+                    # Now process test results
+                    #
+                    if passed == False:
+                        num_exce_test_failed += 1
+                        exce_failed_desc_str += 'Failed test for input ' + "'%s'; " % (
+                            str(test_input)
+                        )
+                    else:
+                        num_exce_test_passed += 1
+
+                assert num_exce_test_failed + num_exce_test_passed == num_exce_test_cases
+
+                exce_test_result_str = (
+                    test_method_names[0]
+                    + ','
+                    + test_method_names[1]
+                    + ','
+                    + test_method_names[2]
+                    + ','
+                    + argument_name
+                    + ',exception,'
+                    + '%d,' % (num_exce_test_cases)
+                )
+                if num_exce_test_failed == 0:
+                    exce_test_result_str += 'all tests passed'
+                else:
+                    exce_test_result_str += '%d tests failed,' % (num_exce_test_failed)
+                    exce_test_result_str += '"' + exce_failed_desc_str[:-2] + '"'
+
+                test_res_list.append(exce_test_result_str)
+
+            test_res_list.append('')  # Empty line between tests of methods
+
+        return test_res_list
+
+    def testFunct_char_set_ascii(self):
+        """Test the functionality of 'char_set_ascii', making sure this function
+        returns a correct string containing the set of corresponding characters.
+        """
+
+        print('Testing functionality of "char_set_ascii"')
+
+        num_passed = 0
+        num_failed = 0
+        num_tests = 0
+        failed_tests_desc = ''
+
+        test_cases = {
+            '0123456789': ['1', '234', '9746298136491', '99999999999999999999999999'],
+            '0123456789 ': [
+                '1 2 3',
+                ' 0 0 0 ',
+                '   234' '409324 12430 32578',
+                '0000000 00000',
+            ],
+            'abcdefghijklmnopqrstuvwxyz': [
+                'abc',
+                'aaaaaaaaaaaa',
+                'aaabbbccc',
+                'cdhiofeakjbdakfhoweuar',
+                'ABC',
+            ],
+            'abcdefghijklmnopqrstuvwxyz ': [
+                ' a b c ',
+                'aaaa aaaa  ',
+                'aaa bbb ccc',
+                ' cdhiofeakjbdakfhoweuar',
+                'AB C',
+            ],
+            'abcdefghijklmnopqrstuvwxyz0123456789': [
+                '1234sdfj12998',
+                '12345678a',
+                'afdadgf34kafh',
+                '1a2b3c',
+            ],
+            'abcdefghijklmnopqrstuvwxyz0123456789 ': [
+                '1234  sdfj 12998',
+                ' 12345678a ',
+                'afdadgf 34 kafh',
+                ' 1 a 2 b 3 c ',
+            ],
+        }
+
+        for char_set_type in test_cases:
+
+            this_type_test_cases = test_cases[char_set_type]
+
+            for test_case in this_type_test_cases:
+                if basefunctions.char_set_ascii(test_case) == char_set_type:
+                    num_passed += 1
+                else:
+                    num_failed += 1
+
+                    failed_tests_desc += "Failed with input string: '%s'; " % (test_case)
+                num_tests += 1
+
+        test_result_str = 'basefunctions,n/a,char_set_ascii,' + 'n/a,funct,%d,' % (
+            num_tests
+        )
+
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed,' % (num_failed)
+            test_result_str += '"' + failed_tests_desc[:-2] + '"'
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_float_to_str(self):
+        """Test the functionality of 'float_to_str', making sure this function
+        returns a correct string of the number with the specified number of
+        digits behind the comma.
+        """
+
+        print('Testing functionality of "float_to_str"')
+
+        num_passed = 0
+        num_failed = 0
+        num_tests = 0
+        failed_tests_desc = ''
+
+        test_cases = {
+            'int': {
+                1: '1',
+                1.0: '1',
+                123.0: '123',
+                -123: '-123',
+                1000.0001: '1000',
+                56.7: '57',
+            },
+            'float1': {
+                1: '1.0',
+                1.0: '1.0',
+                -123: '-123.0',
+                1000.127: '1000.1',
+                56.78: '56.8',
+            },
+            'float2': {
+                1: '1.00',
+                1.0: '1.00',
+                -123: '-123.00',
+                1000.127: '1000.13',
+                56.78: '56.78',
+            },
+            'float3': {
+                1: '1.000',
+                -123: '-123.000',
+                999.999: '999.999',
+                999.99999: '1000.000',
+            },
+            'float4': {
+                1: '1.0000',
+                -1.0: '-1.0000',
+                4.56789: '4.5679',
+                999.99999: '1000.0000',
+            },
+            'float5': {
+                1: '1.00000',
+                -1.0: '-1.00000',
+                4.456789: '4.45679',
+                999.999999: '1000.00000',
+            },
+            'float6': {
+                1: '1.000000',
+                -123: '-123.000000',
+                4.3456789: '4.345679',
+                123.12: '123.120000',
+                999.9999999: '1000.000000',
+            },
+            'float7': {
+                1: '1.0000000',
+                -23.4: '-23.4000000',
+                4.23456789: '4.2345679',
+                123.12: '123.1200000',
+                999.99999999: '1000.0000000',
+            },
+            'float8': {
+                1: '1.00000000',
+                -1.0: '-1.00000000',
+                4.123456789: '4.12345679',
+                123.12: '123.12000000',
+                999.999999999: '1000.00000000',
+            },
+            'float9': {
+                1: '1.000000000',
+                -1.0: '-1.000000000',
+                4.0123456789: '4.012345679',
+                999.9999999999: '1000.000000000',
+            },
+        }
+
+        for format in test_cases:
+
+            this_format_test_cases = test_cases[format]
+
+            for input_num in this_format_test_cases:
+                if (
+                    basefunctions.float_to_str(input_num, format)
+                    == this_format_test_cases[input_num]
+                ):
+                    num_passed += 1
+                else:
+                    num_failed += 1
+                    failed_tests_desc += "Failed with input number: '%s'; " % (
+                        str(input_num)
+                    )
+                num_tests += 1
+
+        test_result_str = 'basefunctions,n/a,float_to_str,' + 'n/a,funct,%d,' % (num_tests)
+
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed,' % (num_failed)
+            test_result_str += '"' + failed_tests_desc[:-2] + '"'
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_str2comma_separated_list(self):
+        """Test the functionality of 'str2comma_separated_list', making sure this
+        function returns a correct list of values separated by the comma in the
+        input string.
+        """
+
+        print('Testing functionality of "str2comma_separated_list"')
+
+        num_passed = 0
+        num_failed = 0
+        num_tests = 0
+
+        failed_tests_desc = ''
+
+        test_cases = {
+            u'123,456,789': ['123', '456', '789'],
+            u'abcd,efgh,ij': ['abcd', 'efgh', 'ij'],
+            u"abcd,efgh,ij": ['abcd', 'efgh', 'ij'],
+            u'123,abc,f23': ['123', 'abc', 'f23'],
+            u'000,000,000': ['000', '000', '000'],
+            u'#$%,^&*,@?>': ['#$%', '^&*', '@?>'],
+            u'abcd,123 ': ['abcd', '123'],
+            u'123,45;6,7;89': ['123', '45;6', '7;89'],
+            u'fd,g r,er,a w': ['fd', 'g r', 'er', 'a w'],
+            u' fd,gr,er,aw ': ['fd', 'gr', 'er', 'aw'],
+            u'123,456,': ['123', '456', ''],
+        }
+
+        for string_val in test_cases:
+
+            if (
+                basefunctions.str2comma_separated_list(string_val)
+                == test_cases[string_val]
+            ):
+                num_passed += 1
+            else:
+                num_failed += 1
+                failed_tests_desc += "Failed when string input: '%s'; " % (str(string_val))
+            num_tests += 1
+
+        test_result_str = (
+            'basefunctions,n/a,str2comma_separated_list,' + 'n/a,funct,%d,' % (num_tests)
+        )
+
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed,' % (num_failed)
+            test_result_str += '"' + failed_tests_desc[:-2] + '"'
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_read_csv_file(self):
+        """Test the functionality of 'read_csv_file', making sure this function
+        reads a CSV file and returns the correct content of the file.
+
+        This function assumes there are three small test file available:
+        test1.csv, test2.txt, test3.csv
+
+        """
+
+        print('Testing functionality of "read_csv_file"')
+
+        num_passed = 0
+        num_failed = 0
+        num_tests = 0
+        failed_tests_desc = ''
+
+        # For the three test files, give file name, the expected number of records
+        # (assuming there is no header line) and the expected number of attributes
+        # in each record
+        #
+        test_cases = [('test1.csv', 4, 3), ('test2.txt', 5, 4), ('test3.csv', 0, 1)]
+
+        for test_case in test_cases:
+
+            for header_flag in [True, False]:
+                passed = True
+                (header_list, file_data) = basefunctions.read_csv_file(
+                    test_case[0], 'ascii', header_flag
+                )
+                if header_flag == True:
+                    if len(file_data) > 0:
+                        if len(file_data) != test_case[1] - 1:
+                            passed = False
+                    else:  # No records in file
+                        if len(file_data) != 0:
+                            passed = False
+                    if len(header_list) != test_case[2]:
+                        passed = False
+                else:
+                    if header_list != None:
+                        passed = False
+                    if len(file_data) != test_case[1]:
+                        passed = False
+
+                for rec in file_data:
+                    if len(rec) != test_case[2]:
+                        passed = False
+
+                if passed == True:
+                    num_passed += 1
+                else:
+                    num_failed += 1
+                    failed_tests_desc += "Failed reading the file: '%s'; " % (test_case[0])
+            num_tests += 1
+
+        test_result_str = 'basefunctions,n/a,read_csv_file,' + 'n/a,funct,%d,' % (
+            num_tests
+        )
+
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed,' % (num_failed)
+            test_result_str += '"' + failed_tests_desc[:-2] + '"'
+
+        return [test_result_str, '']
+
+    # ---------------------------------------------------------------------------
+
+    def testFunct_write_csv_file(self):
+        """Test the functionality of 'write_csv_file', making sure this function
+        correctly writes a list of values into a CSV file. To test this
+        function we assume the read_csv_file() function is correct.
+        """
+
+        print('Testing functionality of "write_csv_file"')
+
+        num_passed = 0
+        num_failed = 0
+        num_tests = 0
+        failed_tests_desc = ''
+
+        test_cases = [
+            [['test1'], ['test2'], ['test3']],
+            [['1'], ['2'], ['3']],
+            [['test 1'], ['test 2'], ['test 3']],
+            [['%^&'], ['test $#%^'], ['123 @#*(']],
+            [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']],
+            [['1', '2', '3'], ['4', '5', '6']],
+            [['1', '2', '3'], ['4', '5', '6'], ['7', '8']],
+            [
+                ['id1', 'peter', 'lyneham'],
+                ['id2', 'miller', 'dickson'],
+                ['id3', 'smith', 'hackett'],
+            ],
+        ]
+
+        header_lists = [None, ['attr1', 'attr2', 'attr3']]
+
+        for test_case in test_cases:
+
+            for header_list in header_lists:
+                basefunctions.write_csv_file('test.csv', 'ascii', header_list, test_case)
+
+                if header_list != None:
+                    (read_header_list, read_file_data) = basefunctions.read_csv_file(
+                        'test.csv', 'ascii', True
+                    )
+
+                else:
+                    (read_header_list, read_file_data) = basefunctions.read_csv_file(
+                        'test.csv', 'ascii', False
+                    )
+
+            if (read_header_list == header_list) and (read_file_data == test_case):
+                num_passed += 1
+            else:
+                num_failed += 1
+                failed_tests_desc += "Failed writing the data: '%s'; " % (str(test_case))
+            num_tests += 1
+
+        test_result_str = 'basefunctions,n/a,write_csv_file,' + 'n/a,funct,%d,' % (
+            num_tests
+        )
+
+        if num_failed == 0:
+            test_result_str += 'all tests passed'
+        else:
+            test_result_str += '%d tests failed,' % (num_failed)
+            test_result_str += '"' + failed_tests_desc[:-2] + '"'
+
+        return [test_result_str, '']
+
+
+# =============================================================================
+# Generate a time string to be used for the log file
+#
+curr_time_tuple = time.localtime()
+curr_time_str = (
+    str(curr_time_tuple[0])
+    + str(curr_time_tuple[1]).zfill(2)
+    + str(curr_time_tuple[2]).zfill(2)
+    + '-'
+    + str(curr_time_tuple[3]).zfill(2)
+    + str(curr_time_tuple[4]).zfill(2)
+)
+
+# Write test output header line into the log file
+
+Path('logs').mkdir(parents=True, exist_ok=True)
+out_file_name = './logs/basefunctionsTest-%s.csv' % (curr_time_str)
+
+out_file = open(out_file_name, 'w')
+
+out_file.write("Test results generated by basefunctionsTest.py" + os.linesep)
+
+out_file.write("Test started: " + curr_time_str + os.linesep)
+
+out_file.write(os.linesep)
+
+out_file.write(
+    'Module name,Class name,Method name,Arguments,Test_type,'
+    + 'Patterns tested,Summary,Failure description'
+    + os.linesep
+)
+
+out_file.write(os.linesep)
+
+# Create instances for the testcase class that calls all tests
+#
+test_res_list = []
+test_case_ins = TestCase('testArguments')
+test_res_list += test_case_ins.testArguments(test_argument_data_dict)
+
+test_case_ins = TestCase('testFunct_char_set_ascii')
+test_res_list += test_case_ins.testFunct_char_set_ascii()
+
+test_case_ins = TestCase('testFunct_float_to_str')
+test_res_list += test_case_ins.testFunct_float_to_str()
+
+test_case_ins = TestCase('testFunct_str2comma_separated_list')
+test_res_list += test_case_ins.testFunct_str2comma_separated_list()
+
+test_case_ins = TestCase('testFunct_read_csv_file')
+test_res_list += test_case_ins.testFunct_read_csv_file()
+
+test_case_ins = TestCase('testFunct_write_csv_file')
+test_res_list += test_case_ins.testFunct_write_csv_file()
+
+# Write test output results into the log file
+#
+for line in test_res_list:
+    out_file.write(line + os.linesep)
+
+out_file.close()
+
+print('Test results are written to', out_file_name)
+
+for line in test_res_list:
+    print(line)

tests/contdepfunct_test.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import os
+import random
+from pathlib import Path
+
+random.seed(42)
+import time
+import unittest
+
+from geco_data_generator import contdepfunct
+
+
+# Define the number of tests to be done for the functionality tests
+#
+num_tests = 100000
+
+# Define argument test cases here
+#
+test_argument_data_dict = {
+  ('contdepfunct','n/a','blood_pressure_depending_on_age'): \
+    {'age':[[[1],[2],[3],[77],[8],[9],[3.76],[99.9],[129.65],[42]],
+            [[None],[''],['test'],[-65],[999],[-0.03],[130.01],
+             [187.87],[{}],[[]]]]},
+  ('contdepfunct','n/a','salary_depending_on_age'): \
+    {'age':[[[1],[2],[3],[77],[8],[9],[3.76],[99.9],[129.65],[42]],
+            [[None],[''],['test'],[-65],[999],[-0.03],[130.01],
+             [187.87],[{}],[[]]]]}
+}
+
+# =============================================================================
+
+class TestCase(unittest.TestCase):
+
+  # Initialise test case  - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  #
+  def setUp(self):
+    pass # Nothing to initialize
+
+  # Clean up test case  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  #
+  def tearDown(self):
+    pass  # Nothing to clean up
+
+  # ---------------------------------------------------------------------------
+  # Start test cases
+
+  def testArguments(self, test_data):
+    """Test if a function or method can be called or initialised correctly with
+       different values for their input arguments (parameters).
+
+       The argument 'test_data' must be a dictionary with the following
+       structure:
+
+       - Keys are tuples consisting of three strings:
+         (module_name, class_name, function_or_method_name)
+       - Values are dictionaries where the keys are the names of the input
+         argument that is being tested, and the values of these dictionaries
+         are a list that contains two lists. The first list contains valid
+         input arguments ('normal' argument tests) that should pass the test,
+         while the second list contains illegal input arguments ('exception'
+         argument tests) that should raise an exception.
+
+         The lists of test cases are itself lists, each containing a number of
+         input argument values, as many as are expected by the function or
+         method that is being tested.
+
+       This function returns a list containing the test results, where each
+       list element is a string with comma separated values (CSV) which are to
+       be written into the testing log file.
+    """
+
+    test_res_list = []  # The test results, one element per element in the test
+                        # data dictionary
+
+    for (test_method_names, test_method_data) in test_data.items():
+      test_method_name = test_method_names[2]
+      print('Testing arguments for method/function:', test_method_name)
+
+      for argument_name in test_method_data:
+        print('  Testing input argument:', argument_name)
+
+        norm_test_data = test_method_data[argument_name][0]
+        exce_test_data = test_method_data[argument_name][1]
+        print('    Normal test cases:   ', norm_test_data)
+        print('    Exception test cases:', exce_test_data)
+
+        # Conduct normal tests - - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        num_norm_test_cases =  len(norm_test_data)
+        num_norm_test_passed = 0
+        num_norm_test_failed = 0
+        norm_failed_desc_str = ''
+
+        for test_input in norm_test_data:
+          passed = True  # Assume the test will pass :-)
+
+          if (len(test_input) == 0):  # Method has no input argument
+            try:
+              getattr(contdepfunct,test_method_name)()
+            except:
+              passed = False
+
+          elif (len(test_input) == 1):  # Method has one input argument
+            try:
+              getattr(contdepfunct,test_method_name)(test_input[0])
+            except:
+              passed = False
+
+          elif (len(test_input) == 2):  # Method has two input arguments
+            try:
+              getattr(contdepfunct,test_method_name)(test_input[0],
+                                                     test_input[1])
+            except:
+              passed = False
+
+          elif (len(test_input) == 3):  # Method has three input arguments
+            try:
+              getattr(contdepfunct,test_method_name)(test_input[0],
+                                                     test_input[1],
+                                                     test_input[2])
+            except:
+              passed = False
+
+          elif (len(test_input) == 4):  # Method has four input arguments
+            try:
+              getattr(contdepfunct,test_method_name)(test_input[0],
+                                                     test_input[1],
+                                                     test_input[2],
+                                                     test_input[3])
+            except:
+              passed = False
+
+          elif (len(test_input) == 5):  # Method has five input arguments
+            try:
+              getattr(contdepfunct,test_method_name)(test_input[0],
+                                                     test_input[1],
+                                                     test_input[2],
+                                                     test_input[3],
+                                                     test_input[4])
+            except:
+              passed = False
+
+          else:
+            raise Exception('Illegal number of input arguments')
+
+          # Now process test results
+          #
+          if (passed == False):
+            num_norm_test_failed += 1
+            norm_failed_desc_str += 'Failed test for input ' + \
+                                    "'%s'; " % (str(test_input))
+          else:
+            num_norm_test_passed += 1
+
+        assert num_norm_test_failed+num_norm_test_passed == num_norm_test_cases
+
+        norm_test_result_str = test_method_names[0] + ',' + \
+                               test_method_names[1] + ',' + \
+                               test_method_names[2] + ',' + \
+                               argument_name + ',normal,' + \
+                               '%d,' % (num_norm_test_cases)
+        if (num_norm_test_failed == 0):
+          norm_test_result_str += 'all tests passed'
+        else:
+          norm_test_result_str += '%d tests failed,' % (num_norm_test_failed)
+          norm_test_result_str += '"'+norm_failed_desc_str[:-2]+'"'
+
+        test_res_list.append(norm_test_result_str)
+
+        # Conduct exception tests - - - - - - - - - - - - - - - - - - - - - - -
+        #
+        num_exce_test_cases =  len(exce_test_data)
+        num_exce_test_passed = 0
+        num_exce_test_failed = 0
+        exce_failed_desc_str = ''
+
+        for test_input in exce_test_data:
+          passed = True  # Assume the test will pass (i.e. raise an exception)
+
+          if (len(test_input) == 0):  # Method has no input argument
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name))
+            except:
+              passed = False
+
+          elif (len(test_input) == 1):  # Method has one input argument
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name),test_input[0])
+            except:
+              passed = False
+
+          elif (len(test_input) == 2):  # Method has two input arguments
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name),test_input[0],
+                                                       test_input[1])
+            except:
+              passed = False
+
+          elif (len(test_input) == 3):  # Method has three input arguments
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name),test_input[0],
+                                                       test_input[1],
+                                                       test_input[2])
+            except:
+              passed = False
+
+          elif (len(test_input) == 4):  # Method has four input arguments
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name),test_input[0],
+                                                       test_input[1],
+                                                       test_input[2],
+                                                       test_input[3])
+            except:
+              passed = False
+
+          elif (len(test_input) == 5):  # Method has five input arguments
+            try:
+              self.assertRaises(Exception,
+                getattr(contdepfunct,test_method_name),test_input[0],
+                                                       test_input[1],
+                                                       test_input[2],
+                                                       test_input[3],
+                                                       test_input[4])
+            except:
+              passed = False
+
+          else:
+            raise Exception('Illegal number of input arguments')
+
+          # Now process test results
+          #
+          if (passed == False):
+            num_exce_test_failed += 1
+            exce_failed_desc_str += 'Failed test for input ' + \
+                                    "'%s'; " % (str(test_input))
+          else:
+            num_exce_test_passed += 1
+
+        assert num_exce_test_failed+num_exce_test_passed == num_exce_test_cases
+
+        exce_test_result_str = test_method_names[0] + ',' + \
+                               test_method_names[1] + ',' + \
+                               test_method_names[2] + ',' + \
+                               argument_name + ',exception,' + \
+                               '%d,' % (num_exce_test_cases)
+        if (num_exce_test_failed == 0):
+          exce_test_result_str += 'all tests passed'
+        else:
+          exce_test_result_str += '%d tests failed,' % (num_exce_test_failed)
+          exce_test_result_str += '"'+exce_failed_desc_str[:-2]+'"'
+
+        test_res_list.append(exce_test_result_str)
+
+      test_res_list.append('')  # Empty line between tests of methods
+
+    return test_res_list
+
+  # ---------------------------------------------------------------------------
+
+  def testFunct_blood_pressure_depending_on_age(self, num_tests):
+    """Test the functionality of 'blood_pressure_depending_on_age', making
+       sure this function returns a positive floating point value.
+    """
+
+    print('Testing functionality of "blood_pressure_depending_on_age"')
+
+    num_passed = 0
+    num_failed = 0
+
+    for i in range(num_tests):
+
+      age = random.uniform(0.0, 120.0)
+
+      try:
+        assert (contdepfunct.blood_pressure_depending_on_age(age) >= 0.0)
+        num_passed += 1
+      except:
+        num_failed += 1
+
+    assert num_passed + num_failed == num_tests
+
+    test_result_str = 'contdepfunct,n/a,blood_pressure_depending_on_age,' + \
+                      'n/a,funct,%d,' % (num_tests)
+    if (num_failed == 0):
+      test_result_str += 'all tests passed'
+    else:
+      test_result_str += '%d tests failed' % (num_failed)
+
+    return [test_result_str,'']
+
+  # ---------------------------------------------------------------------------
+
+  def testFunct_salary_depending_on_age(self, num_tests):
+    """Test the functionality of 'salary_depending_on_age', making sure
+       this function returns a positive floating point value.
+    """
+
+    print('Testing functionality of "salary_depending_on_age"')
+
+    num_passed = 0
+    num_failed = 0
+
+    for i in range(num_tests):
+
+      age = random.uniform(0.0, 120.0)
+
+      try:
+        assert (contdepfunct.salary_depending_on_age(age) >= 0.0)
+        num_passed += 1
+      except:
+        num_failed += 1
+
+    assert num_passed + num_failed == num_tests
+
+    test_result_str = 'contdepfunct,n/a,salary_depending_on_age,' + \
+                      'n/a,funct,%d,' % (num_tests)
+    if (num_failed == 0):
+      test_result_str += 'all tests passed'
+    else:
+      test_result_str += '%d tests failed' % (num_failed)
+
+    return [test_result_str,'']
+
+# =============================================================================
+# Generate a time string to be used for the log file
+#
+curr_time_tuple = time.localtime()
+curr_time_str = str(curr_time_tuple[0]) + str(curr_time_tuple[1]).zfill(2) + \
+                str(curr_time_tuple[2]).zfill(2) + '-' + \
+                str(curr_time_tuple[3]).zfill(2) + \
+                str(curr_time_tuple[4]).zfill(2)
+
+# Write test output header line into the log file
+#
+Path('./logs').mkdir(exist_ok=True)
+out_file_name = './logs/contdepfunctTest-%s.csv' % (curr_time_str)
+
+out_file = open(out_file_name, 'w')
+
+out_file.write('Test results generated by contdepfunctTest.py'  + os.linesep)
+
+out_file.write('Test started: ' + curr_time_str + os.linesep)
+
+out_file.write(os.linesep)
+
+out_file.write('Module name,Class name,Method name,Arguments,Test_type,' + \
+               'Patterns tested,Summary,Failure description' + os.linesep)
+out_file.write(os.linesep)
+
+# Create instances for the testcase class that calls all tests
+#
+test_res_list = []
+test_case_ins = TestCase('testArguments')
+test_res_list += test_case_ins.testArguments(test_argument_data_dict)
+
+test_case_ins = TestCase('testFunct_blood_pressure_depending_on_age')
+test_res_list += \
+  test_case_ins.testFunct_blood_pressure_depending_on_age(num_tests)
+
+test_case_ins = TestCase('testFunct_salary_depending_on_age')
+test_res_list += test_case_ins.testFunct_salary_depending_on_age(num_tests)
+
+# Write test output results into the log file
+#
+for line in test_res_list:
+  out_file.write(line + os.linesep)
+
+out_file.close()
+
+print('Test results are written to', out_file_name)
+
+for line in test_res_list:
+  print(line)
+
+

tests/logs/basefunctionsTest-20230130-1746.csv

@@ -0,0 +1,140 @@
+Test results generated by basefunctionsTest.py
+Test started: 20230130-1746
+
+Module name,Class name,Method name,Arguments,Test_type,Patterns tested,Summary,Failure description
+
+basefunctions,n/a,check_is_not_none,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_not_none,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_not_none,value,normal,5,all tests passed
+basefunctions,n/a,check_is_not_none,value,exception,1,all tests passed
+
+basefunctions,n/a,check_is_string,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_string,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_string,value,normal,7,all tests passed
+basefunctions,n/a,check_is_string,value,exception,4,all tests passed
+
+basefunctions,n/a,check_is_unicode_string,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_unicode_string,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_unicode_string,value,normal,4,all tests passed
+basefunctions,n/a,check_is_unicode_string,value,exception,6,6 tests failed,"Failed test for input '['testArgument', None]'; Failed test for input '['testArgument', '']'; Failed test for input '['testArgument', -123]'; Failed test for input '['testArgument', 123]'; Failed test for input '['testArgument', 1.87]'; Failed test for input '['testArgument', 'ascii']'"
+
+basefunctions,n/a,check_is_string_or_unicode_string,variable,normal,4,all tests passed
+basefunctions,n/a,check_is_string_or_unicode_string,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_string_or_unicode_string,value,normal,6,all tests passed
+basefunctions,n/a,check_is_string_or_unicode_string,value,exception,6,all tests passed
+
+basefunctions,n/a,check_is_non_empty_string,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_non_empty_string,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_non_empty_string,value,normal,6,all tests passed
+basefunctions,n/a,check_is_non_empty_string,value,exception,7,all tests passed
+
+basefunctions,n/a,check_is_number,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_number,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_number,value,normal,6,all tests passed
+basefunctions,n/a,check_is_number,value,exception,8,all tests passed
+
+basefunctions,n/a,check_is_positive,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_positive,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_positive,value,normal,7,all tests passed
+basefunctions,n/a,check_is_positive,value,exception,8,all tests passed
+
+basefunctions,n/a,check_is_not_negative,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_not_negative,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_not_negative,value,normal,9,all tests passed
+basefunctions,n/a,check_is_not_negative,value,exception,8,all tests passed
+
+basefunctions,n/a,check_is_normalised,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_normalised,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_normalised,value,normal,10,all tests passed
+basefunctions,n/a,check_is_normalised,value,exception,10,all tests passed
+
+basefunctions,n/a,check_is_percentage,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_percentage,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_percentage,value,normal,14,all tests passed
+basefunctions,n/a,check_is_percentage,value,exception,10,all tests passed
+
+basefunctions,n/a,check_is_integer,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_integer,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_integer,value,normal,8,all tests passed
+basefunctions,n/a,check_is_integer,value,exception,10,all tests passed
+
+basefunctions,n/a,check_is_float,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_float,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_float,value,normal,6,all tests passed
+basefunctions,n/a,check_is_float,value,exception,10,all tests passed
+
+basefunctions,n/a,check_is_dictionary,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_dictionary,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_dictionary,value,normal,3,all tests passed
+basefunctions,n/a,check_is_dictionary,value,exception,4,all tests passed
+
+basefunctions,n/a,check_is_list,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_list,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_list,value,normal,4,all tests passed
+basefunctions,n/a,check_is_list,value,exception,4,all tests passed
+
+basefunctions,n/a,check_is_set,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_set,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_set,value,normal,4,all tests passed
+basefunctions,n/a,check_is_set,value,exception,6,all tests passed
+
+basefunctions,n/a,check_is_tuple,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_tuple,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_tuple,value,normal,5,all tests passed
+basefunctions,n/a,check_is_tuple,value,exception,8,all tests passed
+
+basefunctions,n/a,check_is_flag,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_flag,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_flag,value,normal,6,all tests passed
+basefunctions,n/a,check_is_flag,value,exception,6,all tests passed
+
+basefunctions,n/a,check_unicode_encoding_exists,unicode_encoding_string,normal,3,all tests passed
+basefunctions,n/a,check_unicode_encoding_exists,unicode_encoding_string,exception,4,all tests passed
+
+basefunctions,n/a,check_is_function_or_method,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_function_or_method,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_function_or_method,value,normal,4,all tests passed
+basefunctions,n/a,check_is_function_or_method,value,exception,6,all tests passed
+
+basefunctions,n/a,char_set_ascii,string_variable,normal,5,all tests passed
+basefunctions,n/a,char_set_ascii,string_variable,exception,6,all tests passed
+
+basefunctions,n/a,check_is_valid_format_str,variable,normal,3,all tests passed
+basefunctions,n/a,check_is_valid_format_str,variable,exception,6,all tests passed
+basefunctions,n/a,check_is_valid_format_str,value,normal,10,all tests passed
+basefunctions,n/a,check_is_valid_format_str,value,exception,8,all tests passed
+
+basefunctions,n/a,float_to_str,number_variable,normal,5,all tests passed
+basefunctions,n/a,float_to_str,number_variable,exception,6,all tests passed
+basefunctions,n/a,float_to_str,format_string,normal,10,all tests passed
+basefunctions,n/a,float_to_str,format_string,exception,8,all tests passed
+
+basefunctions,n/a,str2comma_separated_list,string_variable,normal,8,all tests passed
+basefunctions,n/a,str2comma_separated_list,string_variable,exception,6,1 tests failed,"Failed test for input '['']'"
+
+basefunctions,n/a,read_csv_file,file_name,normal,3,all tests passed
+basefunctions,n/a,read_csv_file,file_name,exception,6,all tests passed
+basefunctions,n/a,read_csv_file,encoding,normal,4,all tests passed
+basefunctions,n/a,read_csv_file,encoding,exception,6,all tests passed
+basefunctions,n/a,read_csv_file,header_line,normal,6,all tests passed
+basefunctions,n/a,read_csv_file,header_line,exception,6,all tests passed
+
+basefunctions,n/a,write_csv_file,file_name,normal,4,all tests passed
+basefunctions,n/a,write_csv_file,file_name,exception,6,all tests passed
+basefunctions,n/a,write_csv_file,encoding,normal,4,all tests passed
+basefunctions,n/a,write_csv_file,encoding,exception,6,all tests passed
+basefunctions,n/a,write_csv_file,header_list,normal,6,all tests passed
+basefunctions,n/a,write_csv_file,header_list,exception,6,all tests passed
+basefunctions,n/a,write_csv_file,file_data,normal,6,all tests passed
+basefunctions,n/a,write_csv_file,file_data,exception,7,all tests passed
+
+basefunctions,n/a,char_set_ascii,n/a,funct,26,all tests passed
+
+basefunctions,n/a,float_to_str,n/a,funct,44,all tests passed
+
+basefunctions,n/a,str2comma_separated_list,n/a,funct,10,all tests passed
+
+basefunctions,n/a,read_csv_file,n/a,funct,3,all tests passed
+
+basefunctions,n/a,write_csv_file,n/a,funct,8,all tests passed
+

tests/logs/contdepfunctTest-20230130-1748.csv

@@ -0,0 +1,5 @@
+Test results generated by contdepfunctTest.py
+Test started: 20230130-1748
+
+Module name,Class name,Method name,Arguments,Test_type,Patterns tested,Summary,Failure description
+

tests/logs/contdepfunctTest-20230130-1749.csv

@@ -0,0 +1,15 @@
+Test results generated by contdepfunctTest.py
+Test started: 20230130-1749
+
+Module name,Class name,Method name,Arguments,Test_type,Patterns tested,Summary,Failure description
+
+contdepfunct,n/a,blood_pressure_depending_on_age,age,normal,10,all tests passed
+contdepfunct,n/a,blood_pressure_depending_on_age,age,exception,10,all tests passed
+
+contdepfunct,n/a,salary_depending_on_age,age,normal,10,all tests passed
+contdepfunct,n/a,salary_depending_on_age,age,exception,10,all tests passed
+
+contdepfunct,n/a,blood_pressure_depending_on_age,n/a,funct,100000,all tests passed
+
+contdepfunct,n/a,salary_depending_on_age,n/a,funct,100000,all tests passed
+

tests/main_test.py

@@ -0,0 +1,793 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from pathlib import Path
+
+from geco_data_generator import (
+    attrgenfunct,
+    contdepfunct,
+    basefunctions,
+    generator,
+    corruptor,
+)
+
+do_large_tests = False  # Set to True to run tests to generate large
+# datasets - warning is time consuming
+import os
+import time
+import unittest
+
+import random
+
+random.seed(42)
+
+# =============================================================================
+
+# Define test cases, each being a list containing the main parameters required
+# for generating a data set:
+# 1) rec_id_attr_name
+# 2) num_org_rec
+# 3) num_dup_rec
+# 4) max_duplicate_per_record
+# 5) num_duplicates_distribution ('uniform', 'poisson', 'zipf')
+# 6) max_modification_per_attr
+# 7) num_modification_per_record
+#
+test_cases = [
+    ['rec_id', 100, 100, 1, 'uniform', 1, 1],
+    ['rec_id', 100, 100, 1, 'poisson', 1, 1],
+    ['rec_id', 100, 100, 1, 'zipf', 1, 1],
+    ['rec_id', 10000, 10000, 1, 'uniform', 1, 1],
+    ['rec_id', 10000, 10000, 1, 'poisson', 1, 1],
+    ['rec_id', 10000, 10000, 1, 'zipf', 1, 1],
+]
+if do_large_tests == True:
+    test_cases += [
+        ['rec_id', 100000, 100000, 1, 'uniform', 1, 1],
+        ['rec_id', 100000, 100000, 1, 'poisson', 1, 1],
+        ['rec_id', 100000, 100000, 1, 'zipf', 1, 1],
+    ]
+#
+test_cases += [
+    ['rec_id', 100, 20, 1, 'uniform', 1, 1],
+    ['rec_id', 100, 20, 1, 'poisson', 1, 1],
+    ['rec_id', 100, 20, 1, 'zipf', 1, 1],
+    ['rec_id', 10000, 2000, 1, 'uniform', 1, 1],
+    ['rec_id', 10000, 2000, 1, 'poisson', 1, 1],
+    ['rec_id', 10000, 2000, 1, 'zipf', 1, 1],
+]
+if do_large_tests == True:
+    test_cases += [
+        ['rec_id', 100000, 20000, 1, 'uniform', 1, 1],
+        ['rec_id', 100000, 20000, 1, 'poisson', 1, 1],
+        ['rec_id', 100000, 20000, 1, 'zipf', 1, 1],
+    ]
+#
+test_cases += [
+    ['rec_num', 123, 321, 5, 'uniform', 1, 3],
+    ['rec_num', 123, 321, 5, 'poisson', 1, 3],
+    ['rec_num', 123, 321, 5, 'zipf', 1, 3],
+    ['rec_num', 12345, 14321, 5, 'uniform', 1, 3],
+    ['rec_num', 12345, 14321, 5, 'poisson', 1, 3],
+    ['rec_num', 12345, 14321, 5, 'zipf', 1, 3],
+]
+if do_large_tests == True:
+    test_cases += [
+        ['rec_num', 123456, 154321, 5, 'uniform', 1, 3],
+        ['rec_num', 123456, 154321, 5, 'poisson', 1, 3],
+        ['rec_num', 123456, 154321, 5, 'zipf', 1, 3],
+    ]
+#
+test_cases += [
+    ['rec_num', 123, 321, 3, 'uniform', 3, 9],
+    ['rec_num', 123, 321, 3, 'poisson', 3, 9],
+    ['rec_num', 123, 321, 3, 'zipf', 3, 9],
+    ['rec_num', 12345, 14321, 3, 'uniform', 3, 9],
+    ['rec_num', 12345, 14321, 3, 'poisson', 3, 9],
+    ['rec_num', 12345, 14321, 3, 'zipf', 3, 9],
+]
+if do_large_tests == True:
+    test_cases += [
+        ['rec_num', 123456, 154321, 3, 'uniform', 3, 9],
+        ['rec_num', 123456, 154321, 3, 'poisson', 3, 9],
+        ['rec_num', 123456, 154321, 3, 'zipf', 3, 9],
+    ]
+#
+test_cases += [
+    ['rec_num', 321, 123, 11, 'uniform', 2, 7],
+    ['rec_num', 321, 123, 11, 'poisson', 2, 7],
+    ['rec_num', 321, 123, 11, 'zipf', 2, 7],
+    ['rec_num', 43210, 14321, 11, 'uniform', 2, 7],
+    ['rec_num', 43210, 14321, 11, 'poisson', 2, 7],
+    ['rec_num', 43210, 14321, 11, 'zipf', 2, 7],
+]
+if do_large_tests == True:
+    test_cases += [
+        ['rec_num', 654321, 123456, 11, 'uniform', 2, 7],
+        ['rec_num', 654321, 123456, 11, 'poisson', 2, 7],
+        ['rec_num', 654321, 123456, 11, 'zipf', 2, 7],
+    ]
+
+# Set the Unicode encoding for all test data generation
+#
+unicode_encoding_used = 'ascii'
+
+# Check the unicode encoding selected is valid
+#
+basefunctions.check_unicode_encoding_exists(unicode_encoding_used)
+
+# =============================================================================
+
+
+class TestCase(unittest.TestCase):
+
+    # Initialise test case  - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def setUp(self):
+        pass  # Nothing to initialize
+
+    # Clean up test case  - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    #
+    def tearDown(self):
+        pass  # Nothing to clean up
+
+    # ---------------------------------------------------------------------------
+    # Start test cases
+
+    def testDataGeneration(self, test_case):
+        """Test the overall generation of a data set according to the parameters
+        given by checking if the generated data sets follows the parameter
+        specification given.
+        """
+
+        rec_id_attr_name = test_case[0]
+        num_org_rec = test_case[1]
+        num_dup_rec = test_case[2]
+        max_duplicate_per_record = test_case[3]
+        num_duplicates_distribution = test_case[4]
+        max_modification_per_attr = test_case[5]
+        num_modification_per_record = test_case[6]
+
+        test_res_list = ['', 'Test case parameters:']
+        test_res_list.append('  rec_id_attr_name = %s' % (rec_id_attr_name))
+        test_res_list.append('  num_org_rec = %s' % (num_org_rec))
+        test_res_list.append('  num_dup_rec = %s' % (num_dup_rec))
+        test_res_list.append(
+            '  max_duplicate_per_record = %s' % (max_duplicate_per_record)
+        )
+        test_res_list.append(
+            '  num_duplicates_distribution = %s' % (num_duplicates_distribution)
+        )
+        test_res_list.append(
+            '  max_modification_per_attr = %s' % (max_modification_per_attr)
+        )
+        test_res_list.append(
+            '  num_modification_per_record = %s' % (num_modification_per_record)
+        )
+        test_res_list.append('')
+
+        # Define the attributes to be generated (based on methods from - - - - -
+        # the generator.py module)
+
+        # Individual attributes
+        #
+        given_name_attr = generator.GenerateFreqAttribute(
+            attribute_name='given-name',
+            freq_file_name='../lookup-files/givenname_freq.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        surnname_attr = generator.GenerateFreqAttribute(
+            attribute_name='surname',
+            freq_file_name='../lookup-files/surname-freq.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        postcode_attr = generator.GenerateFreqAttribute(
+            attribute_name='postcode',
+            freq_file_name='../lookup-files/postcode_act_freq.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        oz_phone_num_attr = generator.GenerateFuncAttribute(
+            attribute_name='oz-phone-number',
+            function=attrgenfunct.generate_phone_number_australia,
+        )
+
+        credit_card_attr = generator.GenerateFuncAttribute(
+            attribute_name='credit-card-number',
+            function=attrgenfunct.generate_credit_card_number,
+        )
+
+        age_uniform_attr = generator.GenerateFuncAttribute(
+            attribute_name='age-uniform',
+            function=attrgenfunct.generate_uniform_age,
+            parameters=[0, 120],
+        )
+
+        age_death_normal_attr = generator.GenerateFuncAttribute(
+            attribute_name='age-death-normal',
+            function=attrgenfunct.generate_normal_age,
+            parameters=[80, 20, 0, 120],
+        )
+
+        income_normal_attr = generator.GenerateFuncAttribute(
+            attribute_name='income-normal',
+            function=attrgenfunct.generate_normal_value,
+            parameters=[75000, 20000, 0, 1000000, 'float2'],
+        )
+
+        rating_normal_attr = generator.GenerateFuncAttribute(
+            attribute_name='rating-normal',
+            function=attrgenfunct.generate_normal_value,
+            parameters=[2.5, 1.0, 0.0, 5.0, 'int'],
+        )
+
+        # Compund (dependent) attributes
+        #
+        gender_city_comp_attr = generator.GenerateCateCateCompoundAttribute(
+            categorical1_attribute_name='gender',
+            categorical2_attribute_name='city',
+            lookup_file_name='../lookup-files/gender-city.csv',
+            has_header_line=True,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        gender_income_comp_attr = generator.GenerateCateContCompoundAttribute(
+            categorical_attribute_name='alt-gender',
+            continuous_attribute_name='income',
+            continuous_value_type='float1',
+            lookup_file_name='gender-income.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        gender_city_salary_comp_attr = generator.GenerateCateCateContCompoundAttribute(
+            categorical1_attribute_name='alt-gender-2',
+            categorical2_attribute_name='town',
+            continuous_attribute_name='salary',
+            continuous_value_type='float4',
+            lookup_file_name='gender-city-income.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        age_blood_pressure_comp_attr = generator.GenerateContContCompoundAttribute(
+            continuous1_attribute_name='medical-age',
+            continuous2_attribute_name='blood-pressure',
+            continuous1_funct_name='uniform',
+            continuous1_funct_param=[10, 110],
+            continuous2_function=contdepfunct.blood_pressure_depending_on_age,
+            continuous1_value_type='int',
+            continuous2_value_type='float3',
+        )
+
+        age_salary_comp_attr = generator.GenerateContContCompoundAttribute(
+            continuous1_attribute_name='medical-age-2',
+            continuous2_attribute_name='medical-salary',
+            continuous1_funct_name='normal',
+            continuous1_funct_param=[45, 20, 25, 130],
+            continuous2_function=contdepfunct.salary_depending_on_age,
+            continuous1_value_type='int',
+            continuous2_value_type='float1',
+        )
+
+        # Define how attribute values are to be modified (corrupted) - - - - - -
+        # (based on methods from the corruptor.py module)
+        #
+        average_edit_corruptor = corruptor.CorruptValueEdit(
+            position_function=corruptor.position_mod_normal,
+            char_set_funct=basefunctions.char_set_ascii,
+            insert_prob=0.25,
+            delete_prob=0.25,
+            substitute_prob=0.25,
+            transpose_prob=0.25,
+        )
+
+        sub_tra_edit_corruptor = corruptor.CorruptValueEdit(
+            position_function=corruptor.position_mod_uniform,
+            char_set_funct=basefunctions.char_set_ascii,
+            insert_prob=0.0,
+            delete_prob=0.0,
+            substitute_prob=0.5,
+            transpose_prob=0.5,
+        )
+
+        ins_del_edit_corruptor = corruptor.CorruptValueEdit(
+            position_function=corruptor.position_mod_normal,
+            char_set_funct=basefunctions.char_set_ascii,
+            insert_prob=0.5,
+            delete_prob=0.5,
+            substitute_prob=0.0,
+            transpose_prob=0.0,
+        )
+
+        surname_misspell_corruptor = corruptor.CorruptCategoricalValue(
+            lookup_file_name='surname-misspell.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        ocr_corruptor = corruptor.CorruptValueOCR(
+            position_function=corruptor.position_mod_uniform,
+            lookup_file_name='ocr-variations.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        keyboard_corruptor = corruptor.CorruptValueKeyboard(
+            position_function=corruptor.position_mod_normal, row_prob=0.5, col_prob=0.5
+        )
+
+        phonetic_corruptor = corruptor.CorruptValuePhonetic(
+            position_function=corruptor.position_mod_uniform,
+            lookup_file_name='phonetic-variations.csv',
+            has_header_line=False,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        missing_val_empty_corruptor = corruptor.CorruptMissingValue()
+        missing_val_miss_corruptor = corruptor.CorruptMissingValue(missing_value='miss')
+        missing_val_unkown_corruptor = corruptor.CorruptMissingValue(
+            missing_value='unknown'
+        )
+
+        # Define the attributes to be generated for this data set, and the data
+        # set itself
+        #
+        attr_name_list = [
+            'given-name',
+            'surname',
+            'city',
+            'postcode',
+            'oz-phone-number',
+            'credit-card-number',
+            'age-uniform',
+            'age-death-normal',
+            'income-normal',
+            'rating-normal',
+            'gender',
+            'alt-gender',
+            'alt-gender-2',
+            'town',
+            'income',
+            'salary',
+            'medical-age',
+            'blood-pressure',
+            'medical-age-2',
+            'medical-salary',
+        ]
+
+        attr_data_list = [
+            given_name_attr,
+            surnname_attr,
+            postcode_attr,
+            oz_phone_num_attr,
+            credit_card_attr,
+            age_uniform_attr,
+            age_death_normal_attr,
+            income_normal_attr,
+            rating_normal_attr,
+            gender_city_comp_attr,
+            gender_income_comp_attr,
+            gender_city_salary_comp_attr,
+            age_blood_pressure_comp_attr,
+            age_salary_comp_attr,
+        ]
+
+        # Initialise the main data generator
+        #
+        test_data_generator = generator.GenerateDataSet(
+            output_file_name='no-file-name',
+            write_header_line=True,
+            rec_id_attr_name=rec_id_attr_name,
+            number_of_records=num_org_rec,
+            attribute_name_list=attr_name_list,
+            attribute_data_list=attr_data_list,
+            unicode_encoding=unicode_encoding_used,
+        )
+
+        # Define distribution of how likely an attribute will be selected for
+        # modification (sum of probabilities must be 1.0)
+        #
+        attr_mod_prob_dictionary = {
+            'given-name': 0.1,
+            'surname': 0.1,
+            'city': 0.1,
+            'postcode': 0.1,
+            'oz-phone-number': 0.1,
+            'age-death-normal': 0.1,
+            'income-normal': 0.1,
+            'gender': 0.1,
+            'town': 0.1,
+            'income': 0.1,
+        }
+
+        # For each attribute, a distribution of which corruptors to apply needs
+        # to be given, with the sum ofprobabilities to be 1.0 for each attribute
+        #
+        attr_mod_data_dictionary = {
+            'given-name': [
+                (0.25, average_edit_corruptor),
+                (0.25, ocr_corruptor),
+                (0.25, phonetic_corruptor),
+                (0.25, missing_val_miss_corruptor),
+            ],
+            'surname': [(0.5, surname_misspell_corruptor), (0.5, average_edit_corruptor)],
+            'city': [(0.5, keyboard_corruptor), (0.5, missing_val_empty_corruptor)],
+            'postcode': [
+                (0.3, missing_val_unkown_corruptor),
+                (0.7, sub_tra_edit_corruptor),
+            ],
+            'oz-phone-number': [
+                (0.2, missing_val_empty_corruptor),
+                (0.4, sub_tra_edit_corruptor),
+                (0.4, keyboard_corruptor),
+            ],
+            'age-death-normal': [(1.0, missing_val_unkown_corruptor)],
+            'income-normal': [
+                (0.3, keyboard_corruptor),
+                (0.3, ocr_corruptor),
+                (0.4, missing_val_empty_corruptor),
+            ],
+            'gender': [(0.5, sub_tra_edit_corruptor), (0.5, ocr_corruptor)],
+            'town': [
+                (0.2, average_edit_corruptor),
+                (0.3, ocr_corruptor),
+                (0.2, keyboard_corruptor),
+                (0.3, phonetic_corruptor),
+            ],
+            'income': [(1.0, missing_val_miss_corruptor)],
+        }
+
+        # Initialise the main data corruptor
+        #
+        test_data_corruptor = corruptor.CorruptDataSet(
+            number_of_org_records=num_org_rec,
+            number_of_mod_records=num_dup_rec,
+            attribute_name_list=attr_name_list,
+            max_num_dup_per_rec=max_duplicate_per_record,
+            num_dup_dist=num_duplicates_distribution,
+            max_num_mod_per_attr=max_modification_per_attr,
+            num_mod_per_rec=num_modification_per_record,
+            attr_mod_prob_dict=attr_mod_prob_dictionary,
+            attr_mod_data_dict=attr_mod_data_dictionary,
+        )
+
+        passed = True  # Assume the test will pass :-)
+
+        # Start the generation process
+        #
+        try:
+            rec_dict = test_data_generator.generate()
+
+        except Exception as exce_value:  # Something bad happened
+            test_res_list.append(
+                '  generator.generate() raised Exception: "%s"' % (str(exce_value))
+            )
+            return test_res_list  # Abandon test
+
+        num_org_rec_gen = len(rec_dict)
+
+        if num_org_rec_gen != num_org_rec:
+            passed = False
+            test_res_list.append(
+                '  Wrong number of original records generated:'
+                + ' %d, expected %d' % (num_org_rec_gen, num_org_rec)
+            )
+
+        # Corrupt (modify) the original records into duplicate records
+        #
+        try:
+            rec_dict = test_data_corruptor.corrupt_records(rec_dict)
+        except Exception as exce_value:  # Something bad happened
+            test_res_list.append(
+                '  corruptor.corrupt_records() raised '
+                + 'Exception: "%s"' % (str(exce_value))
+            )
+            return test_res_list  # Abandon test
+
+        num_dup_rec_gen = len(rec_dict) - num_org_rec_gen
+
+        if num_dup_rec_gen != num_dup_rec:
+            passed = False
+            test_res_list.append(
+                '  Wrong number of duplicate records generated:'
+                + ' %d, expected %d' % (num_dup_rec_gen, num_dup_rec)
+            )
+
+        num_dup_counts = {}  # Count how many records have a certain number of
+        # duplicates
+
+        # Do tests on all generated records
+        #
+        for (rec_id, rec_list) in rec_dict.iteritems():
+            if len(rec_list) != len(attr_name_list):
+                passed = False
+                test_res_list.append(
+                    '  Record with identifier "%s" contains wrong' % (rec_id)
+                    + ' number of attributes: '
+                    + ' %d, expected %d' % (len(rec_list), len(attr_name_list))
+                )
+
+            if 'org' in rec_id:  # An original record
+
+                # Check the number of duplicates for this record is what is expected
+                #
+                num_dups = 0
+                rec_num = rec_id.split('-')[1]
+
+                for d in range(max_duplicate_per_record * 2):
+                    tmp_rec_id = 'rec-%s-dup-%d' % (rec_num, d)
+                    if tmp_rec_id in rec_dict:
+                        num_dups += 1
+                if num_dups > max_duplicate_per_record:
+                    passed = False
+                    test_res_list.append(
+                        '  Too many duplicate records for original'
+                        + ' record "%s": %d' % (rec_id),
+                        num_dups,
+                    )
+
+                d_count = num_dup_counts.get(num_dups, 0) + 1
+                num_dup_counts[num_dups] = d_count
+
+                # Check no duplicate number is outside expected range
+                #
+                for d in range(max_duplicate_per_record, max_duplicate_per_record * 2):
+                    tmp_rec_id = 'rec-%s-dup-%d' % (rec_num, d)
+                    if tmp_rec_id in rec_dict:
+                        passed = False
+                        test_res_list.append(
+                            '  Illegal duplicate number: %s' % (tmp_rec_id)
+                            + ' (larger than max. number '
+                            + 'of duplicates per record %sd' % (max_duplicate_per_record)
+                        )
+
+                # Check values in certain attributes only contain letters
+                #
+                for i in [0, 1, 2, 10, 11, 12, 13]:
+                    test_val = rec_list[i].replace(' ', '')
+                    test_val = test_val.replace('-', '')
+                    test_val = test_val.replace("'", '')
+                    if test_val.isalpha() == False:
+                        passed = False
+                        test_res_list.append(
+                            '  Value in attribute "%s" is not only ' % (attr_name_list[i])
+                            + 'letters:'
+                        )
+                        test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                # Check values in certain attributes only contain digits
+                #
+                for i in [3, 4, 5, 6, 7, 8, 9, 14, 15, 16, 17, 18, 19]:
+                    test_val = rec_list[i].replace(' ', '')
+                    test_val = test_val.replace('.', '')
+                    if test_val.isdigit() == False:
+                        passed = False
+                        test_res_list.append(
+                            '  Value in attribute "%s" is not only ' % (attr_name_list[i])
+                            + 'digits:'
+                        )
+                        test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                # Check age values are in range
+                #
+                for i in [6, 7, 16]:
+                    test_val = int(rec_list[i].strip())
+                    if (test_val < 0) or (test_val > 130):
+                        passed = False
+                        test_res_list.append(
+                            '  Age value in attribute "%s" is out of' % (attr_name_list[i])
+                            + ' range:'
+                        )
+                        test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                # Check length of postcode, telephone and credit card numbers
+                #
+                if len(rec_list[3]) != 4:
+                    passed = False
+                    test_res_list.append('  Postcode has not 4 digits:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                if (len(rec_list[4]) != 12) or (rec_list[4][0] != '0'):
+                    passed = False
+                    test_res_list.append('  Australian phone number has wrong format:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                # Check 'rating' is between 0 and 5
+                #
+                test_val = int(rec_list[9].strip())
+                if (test_val < 0) or (test_val > 5):
+                    passed = False
+                    test_res_list.append('  "rating-normal" value is out of range:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                # Check gender values
+                #
+                test_val = rec_list[10]
+                if test_val not in ['male', 'female']:
+                    passed = False
+                    test_res_list.append('  "gender" value is out of range:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                test_val = rec_list[11]
+                if test_val not in ['m', 'f', 'na']:
+                    passed = False
+                    test_res_list.append('  "alt-gender" value is out of range:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+                test_val = rec_list[12]
+                if test_val not in ['male', 'female']:
+                    passed = False
+                    test_res_list.append('  "alt-gender-2" value is out of range:')
+                    test_res_list.append('    Org: %s' % (str(rec_list)))
+
+            if 'dup' in rec_id:  # A duplicate record
+
+                # Get the corresponding original record
+                #
+                org_rec_id = 'rec-%s-org' % (rec_id.split('-')[1])
+                org_rec_list = rec_dict[org_rec_id]
+
+                # Check the duplicate number
+                #
+                dup_num = int(rec_id.split('-')[-1])
+                if (dup_num < 0) or (dup_num > max_duplicate_per_record - 1):
+                    passed = False
+                    test_res_list.append(
+                        '  Duplicate record with identifier "%s" ' % (rec_id)
+                        + ' has an illegal duplicate number:'
+                        + ' %d' % (dup_num)
+                    )
+                    test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                    test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                # Check that a duplicate record contains the expected - - - - - - - - -
+                # number of modifications
+
+                num_diff_val = 0  # Count how many values are different
+
+                for i in range(len(rec_list)):  # Check all attribute values
+                    if rec_list[i] != org_rec_list[i]:
+                        num_diff_val += 1
+
+                if num_diff_val == 0:  # No differences between org and dup record
+                    passed = False
+                    test_res_list.append(
+                        '  Duplicate record with identifier "%s" ' % (rec_id)
+                        + 'is the same as it original record'
+                    )
+                    test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                    test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                if num_diff_val < num_modification_per_record:
+                    passed = False
+                    test_res_list.append(
+                        '  Duplicate record with identifier "%s" ' % (rec_id)
+                        + 'contains less modifications '
+                        + 'than expected (%d instead of %d)'
+                        % (num_diff_val, num_modification_per_record)
+                    )
+                    test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                    test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                # Check that certain attributes have not been modified
+                #
+                for i in [5, 6, 9, 11, 12, 15, 16, 17, 18, 19]:
+                    if rec_list[i] != org_rec_list[i]:
+                        passed = False
+                        test_res_list.append(
+                            '  Duplicate record with identifier "%s" ' % (rec_id)
+                            + 'contains modified attribute '
+                            + 'values that should not be modified'
+                        )
+                        test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                        test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                # Check the content of certain attribute values, and how they
+                # differ between original and duplicate records
+                #
+                # Due to the possibility thatmultiple modifications are applied on the
+                # same attribute these tests are limited
+
+                test_org_val = org_rec_list[2]  # City
+                test_dup_val = rec_list[2]
+                if test_dup_val != '':
+                    if len(test_org_val) != len(test_dup_val):
+                        passed = False
+                        test_res_list.append('  "city" values have different length:')
+                        test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                        test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                test_org_val = org_rec_list[4]  # Australian phone number
+                test_dup_val = rec_list[4]
+                if test_dup_val != '':
+                    if len(test_org_val) != len(test_dup_val):
+                        passed = False
+                        test_res_list.append(
+                            '  "oz-phone-number" values have different' + ' length:'
+                        )
+                        test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                        test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                test_org_val = org_rec_list[7]  # Age-death-normal
+                test_dup_val = rec_list[7]
+                if test_dup_val != 'unknown':
+                    if test_org_val != test_dup_val:
+                        passed = False
+                        test_res_list.append('  Wrong value for "age-death-normal":')
+                        test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                        test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+                test_org_val = org_rec_list[14]  # Income
+                test_dup_val = rec_list[14]
+                if test_dup_val != 'miss':
+                    if test_org_val != test_dup_val:
+                        passed = False
+                        test_res_list.append('  Wrong value for "income":')
+                        test_res_list.append('    Org: %s' % (str(org_rec_list)))
+                        test_res_list.append('    Dup: %s' % (str(rec_list)))
+
+        test_res_list.append(
+            '  Distribution of duplicates: ("%s" expected)' % num_duplicates_distribution
+        )
+        dup_keys = num_dup_counts.keys()
+        dup_keys.sort()
+        for d in dup_keys:
+            test_res_list.append('    %d: %d records' % (d, num_dup_counts[d]))
+        test_res_list.append('')
+
+        if passed == True:
+            test_res_list.append('  All tests passed')
+        test_res_list.append('')
+
+        return test_res_list
+
+
+# =============================================================================
+# Generate a time string to be used for the log file
+#
+curr_time_tuple = time.localtime()
+curr_time_str = (
+    str(curr_time_tuple[0])
+    + str(curr_time_tuple[1]).zfill(2)
+    + str(curr_time_tuple[2]).zfill(2)
+    + '-'
+    + str(curr_time_tuple[3]).zfill(2)
+    + str(curr_time_tuple[4]).zfill(2)
+)
+
+# Write test output header line into the log file
+#
+Path('./logs').mkdir(exist_ok=True)
+out_file_name = './logs/mainTest-%s.txt' % (curr_time_str)
+
+out_file = open(out_file_name, 'w')
+
+out_file.write('Test results generated by mainTest.py' + os.linesep)
+
+out_file.write('Test started: ' + curr_time_str + os.linesep)
+
+out_file.write(os.linesep)
+
+for test_case in test_cases:
+
+    # Create instances for the testcase class that calls all tests
+    #
+    test_case_ins = TestCase('testDataGeneration')
+    test_res_list = test_case_ins.testDataGeneration(test_case)
+
+    # Write test output results into the log file
+    #
+    for line in test_res_list:
+        out_file.write(line + os.linesep)
+
+    for line in test_res_list:
+        print(line)
+
+out_file.close()
+
+print('Test results are written to', out_file_name)

tests/test.csv

@@ -0,0 +1,4 @@
+attr1,attr2,attr3
+id1,peter,lyneham
+id2,miller,dickson
+id3,smith,hackett

tests/test1.csv

@@ -0,0 +1,4 @@
+attr1,attr2,attr3
+id1,peter,lyneham
+id2,miller,dickson
+id3,smith,hackett