def test_instantiation(self):
# string as a list
R = genRecordType('abc')
self.assertEqual(R._fields, ('a', 'b', 'c'))
# list of columns
R = genRecordType(['a', 'b', 'c'])
self.assertEqual(R._fields, ('a', 'b', 'c'))
# from generator
R = genRecordType((h for h in ['a', 'b', 'c']))
self.assertEqual(R._fields, ('a', 'b', 'c'))
# from DataSet
try:
from ligature.examples import simpleDataset
R = genRecordType(simpleDataset)
self.assertEqual(R._fields, ('a', 'b', 'c'))
except ImportError:
pass
# One columned
R = genRecordType('a')
r = R(1)
self.assertEqual(r._tuple, (1, ))
def _resolveSources(self):
"""Sources may overlap: if so, only take the latter."""
rawSources = [
source.results if isinstance(source, Composable) else source
for source in self.sources
]
allFields = []
# Gather all the fields
for source in rawSources:
for field in source._RecordType._fields:
allFields.append(field)
scanners = []
sourceFields = set(allFields)
for source in reversed(rawSources):
for field in source._RecordType._fields:
if field in sourceFields:
sourceFields.remove(field)
scanners.append((field, self.ScanClass(source, field)))
if not sourceFields:
break
if not sourceFields:
break
# While we want to prioritize later sources, the fields should
# likely keep the same order, starting with the earlier sources.
# see https://stackoverflow.com/a/12814719/1943640
scanners.sort(key=lambda entry: allFields.index(entry[0]))
self.scanners = tuple(scanner for field, scanner in scanners)
self._resultset = RecordSet(recordType=genRecordType(
field for field, scanner in scanners))
def test_replacement(self):
R = genRecordType('abc')
r = R((1, 2, 3))
r._replace(b=5)
self.assertEqual(r._asdict(), {'a': 1, 'b': 5, 'c': 3})
def test_interfaces(self):
# create the example
R = genRecordType('abc')
r = R((1, 2, 3))
self.assertEqual(r._asdict(), {'a': 1, 'b': 2, 'c': 3})
self.assertEqual(r._tuple, (1, 2, 3))
self.assertEqual(r.values, (1, 2, 3))
def _initializeDataSet(self, dataset, validate=False):
"""Convert the DataSet type into a RecordSet
"""
self._RecordType = genRecordType(dataset.getColumnNames())
columnIxs = range(len(self._RecordType._fields))
records = []
for rix in range(dataset.getRowCount()):
row = tuple(dataset.getValueAt(rix, cix) for cix in columnIxs)
records.append(self._RecordType(row))
self._groups = [tuple(records)]
def test_sanitizingFields(self):
fields = ['Column 1', '3', 'Col@2!']
R = genRecordType(fields)
self.assertEqual(
R._lookup, {
'3': 1,
'C3': 1,
'Col@2!': 2,
'Col_2_': 2,
'Column 1': 0,
'Column_1': 0
})
def __init__(self,
initialData=None,
recordType=None,
initialLabel=None,
validate=False,
scalar_tuples=False,
*args,
**kwargs): #, indexingFunction=None):
"""When creating a new RecordSet, the key is to provide an unambiguous RecordType,
or at least enough information to define one.
"""
# We can initialize with a record type, a record, or an iterable of records
# First check if it's a DataSet object. If so, convert it.
if isinstance(initialData, BasicDataset):
self._initializeDataSet(initialData)
elif recordType:
# create a RecordType, if needed
if not (isinstance(recordType, type)
and issubclass(recordType, RecordType)):
recordType = genRecordType(recordType,
scalar_tuples=scalar_tuples)
if initialData:
self._initializeRaw(recordType, initialData)
else:
self._initializeEmpty(recordType)
elif initialData:
if isinstance(initialData, RecordSet):
self._initializeCopy(initialData)
else:
self._initializeRecords(initialData, validate)
else:
raise ValueError(
"""Insufficient information to initialize the RecordSet."""
""" A RecordType must be implied by the constructor arguments."""
)
# monkey patch for higher speed access
self._columns = tuple(
RecordSetColumn(self, ix)
for ix in range(len(self._RecordType._fields)))
# Initialize mixins
super(RecordSet, self).__init__(*args, **kwargs)
def __init__(self,
sources,
function,
outputLabels,
mapInputs={},
*args,
**kwargs):
# Initialize mixins
super(Calculation, self).__init__(*args, **kwargs)
self._resultset = RecordSet(recordType=genRecordType(outputLabels))
self.subscribe(self._resultset)
self.sources = tuple(sources)
if isinstance(function, (str, unicode)):
self.function = Expression(function)
else:
self.function = function
self._mapInputs = mapInputs
self._resolveSources()
