"""Class Febrl - Main class for Febrl projects.

def __init__(self, **kwargs):

"""Constructor - Set attributes and load list of available projects.

self.version_major = '0.2.2'

self.version_minor = ''

self.version = self.version_major+'.'+self.version_minor

self.license = 'ANUOS Version 1.1'

self.copyright = '(C) 2002, 2003 the Australian National ' + \

'University and others'

self.initial_developers = 'Dr Peter Christen (Department of Computer ' + \

'Science, Australian National University) ' + \

'and Dr Tim Churches (Centre for Epidemiology'+ \

' and Research, New South Wales Department ' + \

'of Health)'

self.contributors = ''

self.description = None

self.febrl_path = os.curdir # Default set to current directory

self.project_names = []

# Process all keyword arguments

#

for (keyword, value) in kwargs.items():

if (keyword == 'febrl_path'):

self.febrl_path = value

elif (keyword == 'description'):

self.description = value

else:

print 'error:Illegal constructor argument keyword: "%s"' % \

(str(keyword))

raise Exception

# Check if Febrl projects are available in the 'project_path' directory by

# scanning the directory for files with '.fbr' file extension

#

file_list = os.listdir(self.febrl_path)

for fn in file_list:

file_name = fn.strip().lower()

if (file_name[-4:] == '.fbr'):

self.project_names.append(file_name)

# ---------------------------------------------------------------------------

def __str__(self):

"""Create a string representation of the Febrl object.

linesep = os.linesep

rep = 'Febrl (Freely extensible biomedical record linkage)' + linesep

rep += '---------------------------------------------------' + linesep

rep += linesep

rep += ' Version: ' + self.version + linesep

rep += ' License: ' + self.license + linesep

rep += ' Copyright: ' + self.copyright + linesep + linesep

rep += ' Initial developers: ' + self.initial_developers + linesep

rep += ' Contributors: ' + self.contributors + linesep + linesep

rep += 'Description: ' + str(self.description) + linesep

rep += 'Febrl path: ' + str(self.febrl_path) + linesep

rep += 'Avaliable projects:' + linesep

if (len(self.project_names) == 0):

rep += ' ' + str(None) + linesep

else:

i = 0

for pn in self.project_names:

rep += str(i).rjust(3) + ': ' + pn + linesep

i += 1

rep += linesep

return rep

# ---------------------------------------------------------------------------

def load_project(self, project, project_path=None):

"""Load a project from file.

# Check project path - - - - - - - - - - - - - - - - - - - - - - - - - - -

#

if (project_path == None): # No project path given, use default

file_name = self.febrl_path

else:

file_name = project_path

if (file_name[-1] != os.sep):

file_name += os.sep # Make sure path ends with a directory separator

# Check input argument type - - - - - - - - - - - - - - - - - - - - - - - -

#

if (type(project) == types.IntType):

try:

file_name += self.project_names[project] # Get project file name

except:

print 'error:Illegal project number: %s' % (str(project))

raise Exception

elif (type(project) == types.StringType):

file_name += project

else:

print 'error:Illegal type for "project" argument, must be either of ' + \

'type string or integer'

raise Exception

# Open project file and load it - - - - - - - - - - - - - - - - - - - - - -

#

f = open(file_name,'r')

loaded_project = cPickle.loads(f.read())

f.close()

loaded_project.febrl = self

return loaded_project

# ---------------------------------------------------------------------------

def new_project(self, **kwargs):

"""Create a new project object and populate it.

new_project = Project(self, **kwargs)

return new_project

# ---------------------------------------------------------------------------

def finalise(self):

"""Finalise a Febrl project.

print '1:'

print '1:Febrl stopped.'

parallel.Barrier() # Make sure all processes are here

parallel.Finalize() # Finalise parallel environment

"""Class for record linkage projects.

# ---------------------------------------------------------------------------

def __init__(self, febrl, **kwargs):

"""Constructor - Create a new project object.

self.febrl = febrl

self.name = ''

self.description = ''

self.file_name = None

self.project_path = febrl.febrl_path # Inherit path

self.block_size = 10000 # File blocking size (in number of records)

self.parallel_write = 'host' # Set either to 'host' (default) or 'all'

for (keyword, value) in kwargs.items():

if (keyword == 'name'):

self.name = value

elif (keyword == 'description'):

self.description = value

elif (keyword == 'file_name'):

self.file_name = value

elif (keyword == 'project_path'):

self.project_path = value

elif (keyword == 'block_size'):

if (not isinstance(value, int)) and (value > 0):

print 'error:Argument "block_size" is not a positive integer'

raise Exception

self.block_size = value

elif (keyword == 'parallel_write'):

if (value not in ['host','all']):

print 'error:Argument "parallel_write" must be set to "host"'+ \

' or "all"'

raise Exception

self.parallel_write = value

else:

print 'error:Illegal constructor argument keyword: "%s"' % \

(str(keyword))

raise Exception

# Set the parallel writing/saving mode - - - - - - - - - - - - - - - - - -

#

parallel.writemode = self.parallel_write

# ---------------------------------------------------------------------------

def __str__(self):

"""Create a string representation for this project.

linesep = os.linesep

rep = linesep + 'Febrl project: "'+self.name + '"' + linesep

rep += ' Description: ' + self.description + linesep

rep += ' Filename: ' + self.file_name + linesep

rep += ' Project path: ' + self.project_path + linesep

return rep

# ---------------------------------------------------------------------------

def save(self, path=None):

"""Save the project into a file (currently a pickled file).

if (path is None):

path = self.project_path # Take the project's path

if (path[-1] != os.sep):

path += os.sep # Make sure path ends with a directory separator

# Unset the current febrl object

#

save_febrl = copy.copy(self.febrl) # Make a deep copy first

self.febrl = None

file_name = path + self.file_name

f = open(file_name, 'w+')

f.write(cPickle.dumps(self, 1))

f.close()

# Restore febrl object

#

self.febrl = save_febrl

# ---------------------------------------------------------------------------

def standardise(self, **kwargs):

"""Clean and standardise the given data set using the defined record

self.input_dataset = None # A reference ot the (raw) input data set

# data set

self.output_dataset = None # A reference to the output data set

self.rec_standardiser = None # Reference to a record standardiser

self.first_record = None # Number of the first record to process

self.number_records = None # Number of records to process

for (keyword, value) in kwargs.items():

if (keyword == 'input_dataset'):

self.input_dataset = value

elif (keyword == 'output_dataset'):

self.output_dataset = value

elif (keyword == 'rec_standardiser'):

self.rec_standardiser = value

elif (keyword == 'first_record'):

if (not isinstance(value, int)) or (value < 0):

print 'error:Argument "first_record" is not a valid integer number'

raise Exception

self.first_record = value

elif (keyword == 'number_records'):

if (not isinstance(value, int)) or (value <= 0):

print 'error:Argument "number_records" is not a positive integer '+ \

'number'

raise Exception

self.number_records = value

else:

print 'error:Illegal constructor argument keyword: "%s"' % \

(str(keyword))

raise Exception

# Do some checks on the input arguments - - - - - - - - - - - - - - - - - -

#

if (self.input_dataset == None):

print 'error:Input data set is not defined'

raise Exception

if (self.output_dataset == None):

print 'error:Output data set is not defined'

raise Exception

elif (self.output_dataset.dataset_type == 'MEMORY'):

print 'error:Output data set can not be a memory based data set'

raise Exception

if (self.output_dataset.access_mode not in ['write','append','readwrite']):

print 'error:Output dataset must be initialised in one of the access' + \

' modes: "write", "append", or "readwrite"'

raise Exception

if (self.rec_standardiser == None):

print 'error:Record standardiser is not defined'

raise Exception

if (self.first_record == None):

self.first_record = 0 # Take default first record in data set

if (self.number_records == None): # Process all records

self.number_records = self.input_dataset.num_records

print '1:'

print '1:***** Standardise data set: "%s" (type "%s")' % \

(self.input_dataset.name, self.input_dataset.dataset_type)

print '1:***** into data set: "%s" (type "%s")' % \

(self.output_dataset.name, self.output_dataset.dataset_type)

print '1:'

# Call the main standardisation routine - - - - - - - - - - - - - - - - - -

# (no indexing will be done)

#

[stand_time, comm_time] = do_load_standard_indexing(self.input_dataset,

self.output_dataset,

self.rec_standardiser,

None,

self.first_record,

self.number_records,

self.block_size)

# ---------------------------------------------------------------------------

def deduplicate(self, **kwargs):

"""Deduplicate the given data set using the defined record standardiser,

self.input_dataset = None # A reference ot the (raw) input data set

self.tmp_dataset = None # A reference to a temporary (random access)

# data set

self.rec_standardiser = None # Reference to a record standardiser

self.rec_comparator = None # Reference to a record comparator

self.blocking_index = None # Reference to a blocking index

self.classifier = None # Reference to a weight vector classifier

self.first_record = None # Number of the first record to process

self.number_records = None # Number of records to process

self.output_histogram = False # Set to True, a file name or False

# (default) if a histogram of weights

# should be printed or saved

self.output_rec_pair_details = False # Set to True, a file name or False

# (default) if record pairs should

# be printed or saved in details

self.output_rec_pair_weights = False # Set to True, a file name or False

# (default) if record pairs should

# be printed or saved with weights

self.output_threshold = None # Set to a weight threshold (only

# record pairs with weights equal to

# or above will be saved and or

# printed)

self.output_assignment = None # Set to 'one2one' if one-to-one

# assignment should be forced

# (default: None)

for (keyword, value) in kwargs.items():

if (keyword == 'input_dataset'):

self.input_dataset = value

elif (keyword == 'tmp_dataset'):

self.tmp_dataset = value

elif (keyword == 'rec_standardiser'):

self.rec_standardiser = value

elif (keyword == 'rec_comparator'):

self.rec_comparator = value

elif (keyword == 'blocking_index'):

self.blocking_index = value

elif (keyword == 'classifier'):

self.classifier = value

elif (keyword == 'first_record'):

if (not isinstance(value, int)) or (value < 0):

print 'error:Argument "first_record" is not a valid integer number'

raise Exception

self.first_record = value

elif (keyword == 'number_records'):

if (not isinstance(value, int)) or (value <= 0):

print 'error:Argument "number_records" is not a positive integer '+ \

'number'

raise Exception

self.number_records = value

elif (keyword == 'output_rec_pair_details'):

if (not isinstance(value, str)) and (value not in [True, False]):

print 'error:Argument "output_rec_pair_details" must be ' + \

'a file name or "True" or "False"'

raise Exception

self.output_rec_pair_details = value

elif (keyword == 'output_rec_pair_weights'):

if (not isinstance(value, str)) and (value not in [True, False]):

print 'error:Argument "output_rec_pair_weights" must be ' + \

'a file name or "True" or "False"'

raise Exception

self.output_rec_pair_weights = value

elif (keyword == 'output_histogram'):

if (not isinstance(value, str)) and (value not in [True, False]):

print 'error:Argument "output_histogram" must be ' + \

'a file name or "True" or "False"'

raise Exception

self.output_histogram = value

elif (keyword == 'output_threshold'):

if (not (isinstance(value, int) or isinstance(value, float))):

print 'error:Argument "output_threshold" is not a number: %s' % \

(str(value))

self.output_threshold = value

elif (keyword == 'output_assignment'):

if (value not in ['one2one', None]):

print 'error:Illegal value for argument "output_assignment": %s' % \

(str(value))

raise Exception

else:

self.output_assignment = value

else:

print 'error:Illegal constructor argument keyword: "%s"' % \

(str(keyword))

raise Exception

# Do some checks on the input arguments - - - - - - - - - - - - - - - - - -

#

if (self.input_dataset == None):

print 'error:Input data set is not defined'

raise Exception

if (self.tmp_dataset == None):

print 'error:Temporary data set is not defined'

raise Exception

elif (self.tmp_dataset.dataset_type not in ['SHELVE', 'MEMORY']):

print 'error:Temporary data set must be a random access data set' + \

' (either Shelve or Memory)'

raise Exception

if (self.tmp_dataset.access_mode not in ['write','append','readwrite']):

print 'error:Temporary data set must be initialised in one of the ' + \

'access modes: "write", "append", or "readwrite"'

raise Exception

# Make sure at least one output is defined

#

if (self.output_rec_pair_weights == False) and \

(self.output_rec_pair_details == False) and \

(self.output_histogram == False):

print 'error:No ouput of results is defined.'

raise Exception

#

# Code above to be removed once output data set functionality implemented

if (self.first_record == None):

self.first_record = 0 # Take default first record in data set

if (self.number_records == None): # Process all records

self.number_records = self.input_dataset.num_records

if (self.rec_comparator == None):

print 'error:No record comparator defined'

raise Exception

if (self.rec_comparator.dataset_a != self.tmp_dataset) or \

(self.rec_comparator.dataset_b != self.tmp_dataset):

print 'error:Illegal data set definition in record comparator'

raise Exception

if (self.blocking_index == None):

print 'error:No blocking index defined'

raise Exception

if (self.classifier == None):

print 'error:No classifier defined'

raise Exception

if (self.classifier.dataset_a != self.tmp_dataset) or \

(self.classifier.dataset_b != self.tmp_dataset):

print 'error:Illegal data set definition in classifier'

raise Exception

total_time = time.time() # Get current time

print '1:'

print '1:***** Deduplicate data set: "%s" (type "%s")' % \

(self.input_dataset.name, self.input_dataset.dataset_type)

print '1:***** Temporary data set: "%s" (type "%s")' % \

(self.tmp_dataset.name, self.tmp_dataset.dataset_type)

print '1:'

print '1:Step 1: Loading, standardisation and indexing'

print '1:-------'

print '1:'

step_1_time = time.time() # Get current time

# Call the main standardisation routine - - - - - - - - - - - - - - - - - -

#

[p, step_1_comm_time] = do_load_standard_indexing(self.input_dataset,

self.tmp_dataset,

self.rec_standardiser,

self.blocking_index,

self.first_record,

self.number_records,

self.block_size)

# If Febrl is run in parallel, collect blocking index in process 0 - - - -

#

if (parallel.rank() == 0):

for p in range(1, parallel.size()):

tmp_time = time.time()

tmp_indexes = parallel.receive(p)

step_1_comm_time += (time.time() - tmp_time)

print '1: Received index from process %i' % (p)

self.blocking_index.merge(tmp_indexes)

else: # Send index to process 0

tmp_time = time.time()

parallel.send(self.blocking_index.index, 0) # Send indexes to process 0

step_1_comm_time += (time.time() - tmp_time)

print '1: Sent index to process 0'

# If run in parallel, broadcast the blocking index from process 0 - - - - -

#

if (parallel.size() > 1):

if (parallel.rank() == 0):

for p in range(1, parallel.size()):

tmp_time = time.time()

parallel.send(self.blocking_index.index, p)

step_1_comm_time += (time.time() - tmp_time)

print '1: Sent index to process %i' % (p)

else:

tmp_time = time.time()

tmp_indexes = parallel.receive(0)

step_1_comm_time += (time.time() - tmp_time)

print '1: Received index from process 0'

self.blocking_index.merge(tmp_indexes)

# Compact the blocking index - - - - - - - - - - - - - - - - - - - - - - -

#

self.blocking_index.compact()

step_1_time = time.time() - step_1_time # Calculate time for step 1

step_1_time_string = output.time_string(step_1_time)

print '1:'

print '1:Step 1 finished in %s' % (step_1_time_string)

# End of step 1 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#

parallel.Barrier() # Make sure all processes are here

# Now re-initialise the temporary data set in read access mode only - - - -

#

self.tmp_dataset.re_initialise('read')

#################### START PARALLEL TEST CODE #############################

# Save temporary data sets and indexes to files (on all processes)

#

if (SAVE_PARALLEL_TEST_FILES == True):

#f = open('tmp_data_set-dedup-'+str(parallel.rank())+'-'+ \

# str(parallel.size()),'w')

#tmp_list = self.tmp_dataset.dict.keys()

#tmp_list.sort()

#for r in tmp_list:

# rec = self.tmp_dataset.dict[r]

# rec_items = rec.items()

# rec_items.sort()

# rec = str(r)+': '+str(rec_items)

# f.write(rec+os.linesep)

#f.close()

f = open('indexes-dedup-'+str(parallel.rank())+'-'+ \

str(parallel.size()),'w')

for i in range (self.blocking_index.num_indexes):

tmp_index = self.blocking_index.index[i].keys()

tmp_index.sort()

for bi in tmp_index:

ind = self.blocking_index.index[i][bi]

ind_list = ind.items()

ind_list.sort()

ii = str(i)+'_'+str(bi)+': '+str(ind_list)

f.write(ii+os.linesep)

f.close()

#################### END PARALLEL TEST CODE ###############################

print '1:'

print '1:Step 2: Perform deduplication within blocks'

print '1:-------'

print '1:'

step_2_time = time.time() # Get current time

step_2_comm_time = 0.0

# Get the record pairs which have to be compared - - - - - - - - - - - - -

#

tmp_time = time.time()

[rec_pair_dict, rec_pair_cnt] = \

indexing.deduplication_rec_pairs(self.blocking_index)

rec_pair_time = time.time() - tmp_time

rec_pair_time_string = output.time_string(rec_pair_time)

print '1:'

print '1: Built record pair dictionary with %i entries in %s' % \

(rec_pair_cnt, rec_pair_time_string)

# And do the comparisons of record pairs into classifer - - - - - - - - - -

#

[p] = do_comparison(self.tmp_dataset, self.tmp_dataset,

self.rec_comparator, self.classifier,

rec_pair_dict, rec_pair_cnt, self.block_size)

# Now gather classifier results on process 0 and merge - - - - - - - - - -

#

if (parallel.size() > 1):

if (parallel.rank() == 0):

for p in range(1, parallel.size()):

tmp_time = time.time()

tmp_classifier_results = parallel.receive(p)

step_2_comm_time += (time.time() - tmp_time)

print '1: Received classifier from process %i and merged it' % (p)

self.classifier.merge(tmp_classifier_results)

else:

tmp_time = time.time()

parallel.send(self.classifier.results, 0) # Send classifier results to

# process 0

step_2_comm_time += (time.time() - tmp_time)

print '1: Sent classifier to process 0'

# If run in parallel, broadcast the classifier results from process 0 - - -

#

if (parallel.size() > 1):

if (parallel.rank() == 0):

for p in range(1, parallel.size()):

tmp_time = time.time()

parallel.send(self.classifier.results, p)

step_2_comm_time += (time.time() - tmp_time)

print '1: Sent classifier to process %i' % (p)

else:

tmp_time = time.time()

self.classifier.results = parallel.receive(0)

step_2_comm_time += (time.time() - tmp_time)

print '1: Received classifier from process 0'

#################### START PARALLEL TEST CODE #############################

# Save classifiers and weight vectors to files (only process 0)

#

if (SAVE_PARALLEL_TEST_FILES == True):

tmp_list = rec_pair_dict.keys()

tmp_list.sort()

f = open('rec-pair-dict-dedup-'+str(parallel.rank())+'-'+ \

str(parallel.size()),'w')

for rp in tmp_list:

rec_list = rec_pair_dict[rp].items()

rec_list.sort()

r = str(rp)+': '+str(rec_list)

f.write(r+os.linesep)

f.close()

tmp_list = self.classifier.results.keys()

tmp_list.sort()

f = open('classifier_results_dict-dedup-'+str(parallel.rank())+'-'+ \

str(parallel.size()),'w')

for c in tmp_list:

res = self.classifier.results[c].items()

res.sort()

ce = str(c)+': '+str(res)

f.write(ce+os.linesep)

f.close()

#################### END PARALLEL TEST CODE ###############################

step_2_time = time.time() - step_2_time # Calculate time for step 2

step_2_time_string = output.time_string(step_2_time)

print '1:'

print '1:Step 2 (deduplication) finished in %s' % (step_2_time_string)

print '1: Totally %i record pair comparisons' % (rec_pair_cnt)

# Output the results - - - - - - - - - - - - - - - - - - - - - - - - - - -

print '1:'

print '1:Step 3: Output and assignment procedures'

print '1:-------'

print '1:'

step_3_time = time.time() # Get current time

# Get the results dictionary with all the record pairs and their weights

#

results_dict = self.classifier.results

if (results_dict == {}):

print 'warning:Results dictionary empty'

else: # There are results

# Do assignment restrictions if they are defined - - - - - - - - - - - -

#

if (self.output_assignment != None): # An output assignment is defined

if (self.output_assignment == 'one2one'):

# Do a one-to-one assignment on the classifier results dict

#

o2o_results_dict = lap.do_lap('auction', results_dict, \

'deduplication', self.output_threshold)

else: # No one-to-one assignment, set one2one result to None

o2o_results_dict = None

#################### START PARALLEL TEST CODE ###########################

if (SAVE_PARALLEL_TEST_FILES == True):

tmp_list = o2o_results_dict.items()

tmp_list.sort()

f = open('one2one-dedup-'+str(parallel.rank())+'-'+ \

str(parallel.size()),'w')

for c in tmp_list:

f.write(str(c)+os.linesep)

f.close()

#################### END PARALLEL TEST CODE #############################

if (parallel.rank() == 0): # Only processor 0 prints results

# Print or save weights histogram - - - - - - - - - - - - - - - - - - -

#

if (self.output_histogram == True):

output.histogram(results_dict)

elif (self.output_histogram != False):

output.histogram(results_dict, self.output_histogram)

# Print or save detailed record pairs - - - - - - - - - - - - - - - - -

#

if (self.output_rec_pair_details == True):

output.rec_pair_details(self.tmp_dataset, self.tmp_dataset,

results_dict, o2o_results_dict,

self.output_threshold)

elif (self.output_rec_pair_details != False):

output.rec_pair_details(self.tmp_dataset, self.tmp_dataset,

results_dict, o2o_results_dict,

self.output_threshold,

self.output_rec_pair_details)

# Print or save record pairs with weights - - - - - - - - - - - - - - -

#

if (self.output_rec_pair_weights == True):

output.rec_pair_weights(self.tmp_dataset.name,

self.tmp_dataset.name,

results_dict, o2o_results_dict,

self.output_threshold)

elif (self.output_rec_pair_weights != False):

output.rec_pair_weights(self.tmp_dataset.name,

self.tmp_dataset.name,

results_dict, o2o_results_dict,

self.output_threshold,

self.output_rec_pair_weights)

step_3_time = time.time() - step_3_time # Calculate time for step 3

step_3_time_string = output.time_string(step_3_time)

print '1:'

print '1:Step 3 (output and assignments) finished in %s' % \

(step_3_time_string)

print '1:'

parallel.Barrier() # Wait here for all processes - - - - - - - - - - - - -

total_time = time.time() - total_time # Calculate total time

total_time_string = output.time_string(total_time)

step_1_comm_time_string = output.time_string(step_1_comm_time)

step_2_comm_time_string = output.time_string(step_2_comm_time)

print '1:Total time needed for deduplication of %i records: %s' % \

(self.number_records, total_time_string)

print '1: Time for step 1 (standardisation): %s' % \

(step_1_time_string)

print '1: Time for step 2 (deduplication): %s' % \

(step_2_time_string)

print '1: Time for step 3 (assignment and output): %s' % \

(step_3_time_string)

print '1: Time for communication in step 1: %s' % \

(step_1_comm_time_string)

print '1: Time for communication in step 2: %s' % \

(step_2_comm_time_string)

# ---------------------------------------------------------------------------

def link(self, **kwargs):

"""Link the given two data set using the defined record standardisers,

self.input_dataset_a = None # A reference to the first input data set

self.tmp_dataset_a = None # A reference to the first temporary

# (random access) data set

self.input_dataset_b = None # A reference ot the second input data set

self.tmp_dataset_b = None # A reference to the second temporary

# (random access) data set

self.rec_standardiser_a = None # Reference to a record standardiser for

# the first data set (A)

self.rec_standardiser_b = None # Reference to a record standardiser for

# the second data set (B)

self.blocking_index_a = None # Reference to a blocking index for data

# the first set (A)

self.blocking_index_b = None # Reference to a blocking index for data

# the second set (B)

self.rec_comparator = None # Reference to a record comparator

self.classifier = None # Reference to a weight vector classifier

self.first_record_a = None # Number of the first record to process

# in the first data set (A)

self.number_records_a = None # Number of records to process in the

# first data set (A)

self.first_record_b = None # Number of the first record to process

# in the second data set (B)

self.number_records_b = None # Number of records to process in the

# second data set (B)

self.output_histogram = False # Set to True, a file name or False

# (default) if a histogram of weights

# should be printed or saved

self.output_rec_pair_details = False # Set to True, a file name or False

# (default) if record pairs should

# be printed or saved in details

self.output_rec_pair_weights = False # Set to True, a file name or False

# (default) if record pairs should

# be printed or saved with weights

self.output_threshold = None # Set to a weight threshold (only

# record pairs with weights equal to

# or above will be saved and or

# printed)

self.output_assignment = None # Set to 'one2one' if one-to-one

# assignment should be forced

# (default: None)

for (keyword, value) in kwargs.items():

if (keyword == 'input_dataset_a'):

self.input_dataset_a = value

elif (keyword == 'input_dataset_b'):

self.input_dataset_b = value

elif (keyword == 'tmp_dataset_a'):

self.tmp_dataset_a = value

elif (keyword == 'tmp_dataset_b'):