class TestTableCompute(unittest.TestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 6, None)
)
self.number_type = Number()
self.text_type = Text()
self.columns = (
('one', self.text_type),
('two', self.number_type),
('three', self.number_type),
('four', self.number_type)
)
self.table = Table(self.rows, self.columns)
def test_compute(self):
new_table = self.table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 6)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.columns['number'], (5, 8, 6, 9))
self.assertSequenceEqual(new_table.columns['text'], ('a3', '-5', 'a4', 'b6'))
def test_compute_multiple(self):
new_table = self.table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'test')
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 9))
def test_compute_with_row_names(self):
table = Table(self.rows, self.columns, row_names='three')
new_table = table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.row_names, (3, 5, 4, 6))
class TestTableCompute(unittest.TestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 6, None)
)
self.number_type = Number()
self.text_type = Text()
self.column_names = [
'one', 'two', 'three', 'four'
]
self.column_types = [
self.text_type, self.number_type, self.number_type, self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_compute(self):
new_table = self.table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 6)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.columns['number'], (5, 8, 6, 9))
self.assertSequenceEqual(new_table.columns['text'], ('a3', '-5', 'a4', 'b6'))
def test_compute_multiple(self):
new_table = self.table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'test')
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 9))
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.row_names, (3, 5, 4, 6))
class TestCompute(AgateTestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 6, None)
)
self.number_type = Number()
self.text_type = Text()
self.column_names = [
'one', 'two', 'three', 'four'
]
self.column_types = [
self.text_type, self.number_type, self.number_type, self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_compute(self):
new_table = self.table.compute([
('test', Formula(self.number_type, lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four', 'test'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number, Number])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 9))
def test_compute_multiple(self):
new_table = self.table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four', 'number', 'text'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number, Number, Text])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.columns['number'], (5, 8, 6, 9))
self.assertSequenceEqual(new_table.columns['text'], ('a3', '-5', 'a4', 'b6'))
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertRowNames(new_table, [3, 5, 4, 6])
def test_change_mixed_types(self):
rows = (("1", "10/24/1978"), ("2", "11/13/1974"))
column_names = ["number", "date"]
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(ValueError):
table.compute([("test", Change("number", "date"))])
def test_change_mixed_types(self):
rows = (('1', '10/24/1978'), ('2', '11/13/1974'))
column_names = ['number', 'date']
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(ValueError):
table.compute([('test', Change('number', 'date'))])
def test_changed_invalid_types(self):
rows = ((False, True), (True, False))
column_names = ['before', 'after']
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([('test', Change('before', 'after'))])
def test_changed_invalid_types(self):
rows = ((False, True), (True, False))
column_names = ["before", "after"]
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([("test", Change("before", "after"))])
def prepare(self, table):
""" Prepare a table with comparison items for each row in table
"""
super(GroupComparison, self).prepare(table)
self.comparison_tables = {}
if self.group_by:
""" Case: Group by category column
"""
self.groups = {}
for group_table in table.group_by(self.group_by):
# Add row name to the grouped tables
group_table = Table(group_table.rows,
column_types=group_table.column_types,
column_names=group_table.column_names,
row_names=self.key)
group_name = group_table.rows[0][self.group_by]
# Apply computation
group_table = group_table.compute([self._get_computation()])
self.groups[group_name] = group_table
for row in table.rows:
row_key = row[self.key]
group_name = row[self.group_by]
self.comparison_tables[row_key] = self.groups[group_name]
elif self.comparison_column:
""" Case: Get comparison items from column
"""
for row in table.rows:
try:
comparison_keys = row[self.comparison_column].split(",")
except AttributeError:
comparison_keys = []
# Add self to comparison table. Needed to be able to rank
comparison_keys += [row[self.key]]
comparison_table = Table(
[table.rows[x] for x in comparison_keys],
column_types=table.column_types,
column_names=table.column_names,
row_names=self.key
)
# Apply computation
comparison_table = comparison_table.compute([self._get_computation()])
self.comparison_tables[row[self.key]] = comparison_table
def test_changed_invalid_types(self):
rows = (
(False, True),
(True, False)
)
column_names = ['before', 'after']
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([
('test', Change('before', 'after'))
])
def test_change_mixed_types(self):
rows = (
('1', '10/24/1978'),
('2', '11/13/1974')
)
column_names = ['number', 'date']
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([
('test', Change('number', 'date'))
])
def prepare(self, table):
""" Prepare a table with comparison items for each row in table
"""
super(GroupComparison, self).prepare(table)
self.comparison_tables = {}
if self.group_by:
""" Case: Group by category column
"""
self.groups = {}
for group_table in table.group_by(self.group_by):
# Add row name to the grouped tables
group_table = Table(group_table.rows,
column_types=group_table.column_types,
column_names=group_table.column_names,
row_names=self.key)
group_name = group_table.rows[0][self.group_by]
# Apply computation
group_table = group_table.compute([self._get_computation()])
self.groups[group_name] = group_table
for row in table.rows:
row_key = row[self.key]
group_name = row[self.group_by]
self.comparison_tables[row_key] = self.groups[group_name]
elif self.comparison_column:
""" Case: Get comparison items from column
"""
for row in table.rows:
try:
comparison_keys = row[self.comparison_column].split(",")
except AttributeError:
comparison_keys = []
# Add self to comparison table. Needed to be able to rank
comparison_keys += [row[self.key]]
comparison_table = Table(
[table.rows[x] for x in comparison_keys],
column_types=table.column_types,
column_names=table.column_names,
row_names=self.key)
# Apply computation
comparison_table = comparison_table.compute(
[self._get_computation()])
self.comparison_tables[row[self.key]] = comparison_table
def test_change_datetimes(self):
rows = (
('10/4/2015 4:43', '10/7/2015 4:50'),
('10/2/2015 12 PM', '9/28/2015 12 PM'),
('9/28/2015 12:00:00', '9/1/2015 6 PM')
)
datetime_type = DateTime()
column_names = ['one', 'two']
column_types = [datetime_type, datetime_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([
('test', Change('one', 'two'))
])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (
datetime.datetime(2015, 10, 4, 4, 43),
datetime.datetime(2015, 10, 7, 4, 50),
datetime.timedelta(days=3, minutes=7)
))
self.assertEqual(new_table.columns['test'][0], datetime.timedelta(days=3, minutes=7))
self.assertEqual(new_table.columns['test'][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2], datetime.timedelta(days=-26, hours=-18))
def test_change_timedeltas(self):
rows = (
('4:15', '8:18'),
('4h 2m', '2h'),
('4 weeks', '27 days')
)
timedelta_type = TimeDelta()
column_names = ['one', 'two']
column_types = [timedelta_type, timedelta_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([
('test', Change('one', 'two'))
])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (
datetime.timedelta(minutes=4, seconds=15),
datetime.timedelta(minutes=8, seconds=18),
datetime.timedelta(minutes=4, seconds=3)
))
self.assertEqual(new_table.columns['test'][0], datetime.timedelta(minutes=4, seconds=3))
self.assertEqual(new_table.columns['test'][1], datetime.timedelta(hours=-2, minutes=-2))
self.assertEqual(new_table.columns['test'][2], datetime.timedelta(days=-1))
def test_change_datetimes(self):
rows = (
("10/4/2015 4:43", "10/7/2015 4:50"),
("10/2/2015 12 PM", "9/28/2015 12 PM"),
("9/28/2015 12:00:00", "9/1/2015 6 PM"),
)
datetime_type = DateTime()
column_names = ["one", "two"]
column_types = [datetime_type, datetime_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([("test", Change("one", "two"))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(
new_table.rows[0],
(
datetime.datetime(2015, 10, 4, 4, 43),
datetime.datetime(2015, 10, 7, 4, 50),
datetime.timedelta(days=3, minutes=7),
),
)
self.assertEqual(new_table.columns["test"][0], datetime.timedelta(days=3, minutes=7))
self.assertEqual(new_table.columns["test"][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns["test"][2], datetime.timedelta(days=-26, hours=-18))
def test_change_timedeltas(self):
rows = (("4:15", "8:18"), ("4h 2m", "2h"), ("4 weeks", "27 days"))
timedelta_type = TimeDelta()
column_names = ["one", "two"]
column_types = [timedelta_type, timedelta_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([("test", Change("one", "two"))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(
new_table.rows[0],
(
datetime.timedelta(minutes=4, seconds=15),
datetime.timedelta(minutes=8, seconds=18),
datetime.timedelta(minutes=4, seconds=3),
),
)
self.assertEqual(new_table.columns["test"][0], datetime.timedelta(minutes=4, seconds=3))
self.assertEqual(new_table.columns["test"][1], datetime.timedelta(hours=-2, minutes=-2))
self.assertEqual(new_table.columns["test"][2], datetime.timedelta(days=-1))
def test_change_dates(self):
rows = (('October 4th', 'October 7th'),
('October 2nd', 'September 28'), ('September 28th', '9/1/15'))
date_type = DateType()
columns = (('one', date_type), ('two', date_type))
table = Table(rows, columns)
new_table = table.compute([('test', Change('one', 'two'))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(
new_table.rows[0],
(datetime.date(2015, 10, 4), datetime.date(
2015, 10, 7), datetime.timedelta(days=3)))
self.assertEqual(new_table.columns['test'][0],
datetime.timedelta(days=3))
self.assertEqual(new_table.columns['test'][1],
datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2],
datetime.timedelta(days=-27))
def test_change_datetimes(self):
rows = (('October 4th 4:43', 'October 7th, 4:50'),
('October 2nd, 12 PM', 'September 28, 12 PM'),
('September 28th, 12:00:00', '9/1/15, 6 PM'))
datetime_type = DateTimeType()
columns = (('one', datetime_type), ('two', datetime_type))
table = Table(rows, columns)
new_table = table.compute([('test', Change('one', 'two'))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (datetime.datetime(
2015, 10, 4, 4, 43), datetime.datetime(
2015, 10, 7, 4, 50), datetime.timedelta(days=3, minutes=7)))
self.assertEqual(new_table.columns['test'][0],
datetime.timedelta(days=3, minutes=7))
self.assertEqual(new_table.columns['test'][1],
datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2],
datetime.timedelta(days=-26, hours=-18))
def test_change_dates(self):
rows = (
('October 4th', 'October 7th'),
('October 2nd', 'September 28'),
('September 28th', '9/1/15')
)
date_type = DateType()
columns = (
('one', date_type),
('two', date_type)
)
table = Table(rows, columns)
new_table = table.compute([
('test', Change('one', 'two'))
])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (
datetime.date(2015, 10, 4),
datetime.date(2015, 10, 7),
datetime.timedelta(days=3)
))
self.assertEqual(new_table.columns['test'][0], datetime.timedelta(days=3))
self.assertEqual(new_table.columns['test'][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2], datetime.timedelta(days=-27))
def test_change_datetimes(self):
rows = (
('October 4th 4:43', 'October 7th, 4:50'),
('October 2nd, 12 PM', 'September 28, 12 PM'),
('September 28th, 12:00:00', '9/1/15, 6 PM')
)
datetime_type = DateTimeType()
columns = (
('one', datetime_type),
('two', datetime_type)
)
table = Table(rows, columns)
new_table = table.compute([
('test', Change('one', 'two'))
])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (
datetime.datetime(2015, 10, 4, 4, 43),
datetime.datetime(2015, 10, 7, 4, 50),
datetime.timedelta(days=3, minutes=7)
))
self.assertEqual(new_table.columns['test'][0], datetime.timedelta(days=3, minutes=7))
self.assertEqual(new_table.columns['test'][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2], datetime.timedelta(days=-26, hours=-18))
def test_change_dates(self):
rows = (
('10/4/2015', '10/7/2015'),
('10/2/2015', '9/28/2015'),
('9/28/2015', '9/1/2015')
)
date_type = Date()
column_names = ['one', 'two']
column_types = [date_type, date_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([
('test', Change('one', 'two'))
])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (
datetime.date(2015, 10, 4),
datetime.date(2015, 10, 7),
datetime.timedelta(days=3)
))
self.assertEqual(new_table.columns['test'][0], datetime.timedelta(days=3))
self.assertEqual(new_table.columns['test'][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2], datetime.timedelta(days=-27))
class TestTableCompute(unittest.TestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 4, None)
)
self.number_type = NumberType()
self.text_type = TextType()
self.columns = (
('one', self.text_type),
('two', self.number_type),
('three', self.number_type),
('four', self.number_type)
)
self.table = Table(self.rows, self.columns)
def test_compute(self):
new_table = self.table.compute([
('test', Formula(self.number_type, lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 7))
class TestTableCompute(unittest.TestCase):
def setUp(self):
self.rows = (('a', 2, 3, 4), (None, 3, 5, None), ('a', 2, 4, None),
('b', 3, 4, None))
self.number_type = NumberType()
self.text_type = TextType()
self.columns = (('one', self.text_type), ('two', self.number_type),
('three', self.number_type), ('four',
self.number_type))
self.table = Table(self.rows, self.columns)
def test_compute(self):
new_table = self.table.compute([
('test', Formula(self.number_type,
lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 7))
def test_change_timedeltas(self):
rows = (('4:15', '8:18'), ('4h 2m', '2h'), ('4 weeks', '27 days'))
timedelta_type = TimeDelta()
column_names = ['one', 'two']
column_types = [timedelta_type, timedelta_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([('test', Change('one', 'two'))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0],
(datetime.timedelta(minutes=4, seconds=15),
datetime.timedelta(minutes=8, seconds=18),
datetime.timedelta(minutes=4, seconds=3)))
self.assertEqual(new_table.columns['test'][0],
datetime.timedelta(minutes=4, seconds=3))
self.assertEqual(new_table.columns['test'][1],
datetime.timedelta(hours=-2, minutes=-2))
self.assertEqual(new_table.columns['test'][2],
datetime.timedelta(days=-1))
def test_change_datetimes(self):
rows = (('10/4/2015 4:43', '10/7/2015 4:50'),
('10/2/2015 12 PM', '9/28/2015 12 PM'), ('9/28/2015 12:00:00',
'9/1/2015 6 PM'))
datetime_type = DateTime()
column_names = ['one', 'two']
column_types = [datetime_type, datetime_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([('test', Change('one', 'two'))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(new_table.rows[0], (datetime.datetime(
2015, 10, 4, 4, 43), datetime.datetime(
2015, 10, 7, 4, 50), datetime.timedelta(days=3, minutes=7)))
self.assertEqual(new_table.columns['test'][0],
datetime.timedelta(days=3, minutes=7))
self.assertEqual(new_table.columns['test'][1],
datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2],
datetime.timedelta(days=-26, hours=-18))
def test_change_dates(self):
rows = (('10/4/2015', '10/7/2015'), ('10/2/2015', '9/28/2015'),
('9/28/2015', '9/1/2015'))
date_type = Date()
column_names = ['one', 'two']
column_types = [date_type, date_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([('test', Change('one', 'two'))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(
new_table.rows[0],
(datetime.date(2015, 10, 4), datetime.date(
2015, 10, 7), datetime.timedelta(days=3)))
self.assertEqual(new_table.columns['test'][0],
datetime.timedelta(days=3))
self.assertEqual(new_table.columns['test'][1],
datetime.timedelta(days=-4))
self.assertEqual(new_table.columns['test'][2],
datetime.timedelta(days=-27))
def test_changed_invalid_types(self):
rows = (
(False, True),
(True, False)
)
columns = (
('before', Boolean()),
('after', Boolean())
)
table = Table(rows, columns)
with self.assertRaises(DataTypeError):
table.compute([
(Change('before', 'after'), 'test')
])
def test_change_mixed_types(self):
rows = (
('1', '10/24/1978'),
('2', '11/13/1974')
)
columns = (
('number', Number()),
('date', Date())
)
table = Table(rows, columns)
with self.assertRaises(ValueError):
table.compute([
('test', Change('number', 'date'))
])
def test_change_mixed_types(self):
rows = (
('1', '10/24/1978'),
('2', '11/13/1974')
)
columns = (
('number', Number()),
('date', Date())
)
table = Table(rows, columns)
with self.assertRaises(ValueError):
table.compute([
(Change('number', 'date'), 'test')
])
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertRowNames(new_table, [3, 5, 4, 6])
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertRowNames(new_table, [3, 5, 4, 6])
def test_compute_with_row_names(self):
table = Table(self.rows, self.columns, row_names='three')
new_table = table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.row_names, (3, 5, 4, 6))
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
(Formula(self.number_type, lambda r: r['two'] + r['three']), 'number'),
(Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])), 'text')
])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.row_names, (3, 5, 4, 6))
def test_slug_column_name_sequence(self):
rows = (('hello world', 2, 'Ab*c #e'), ('Ab*c #e', 2, 'He11O W0rld'),
('He11O W0rld', 3, 'hello world'))
expected = [
'hello_world_ab_c_e', 'ab_c_e_he11o_w0rld',
'he11o_w0rld_hello_world'
]
table1 = Table(rows, ['one', 'two', 'three'],
[self.text_type, self.number_type, self.text_type])
table2 = table1.compute([('slugs', Slug(['one', 'three']))])
self.assertSequenceEqual(table2.columns['slugs'], expected)
def test_slug_column_name_sequence(self):
rows = (
('hello world', 2, 'Ab*c #e'),
('Ab*c #e', 2, 'He11O W0rld'),
('He11O W0rld', 3, 'hello world')
)
expected = ['hello-world-ab-c-e', 'ab-c-e-he11o-w0rld', 'he11o-w0rld-hello-world']
table1 = Table(rows, ['one', 'two', 'three'], [self.text_type, self.number_type, self.text_type])
table2 = table1.compute([
('slugs', Slug(['one', 'three']))
])
self.assertSequenceEqual(table2.columns['slugs'], expected)
def test_compute_creates_rows(self):
table = Table(self.rows, self.columns)
table2 = table.compute([
('new2', Formula(self.number_type, lambda r: r['one']))
])
table3 = table2.compute([
('new3', Formula(self.number_type, lambda r: r['one']))
])
self.assertIsNot(table._data[0], table2._data[0])
self.assertNotEqual(table._data[0], table2._data[0])
self.assertIsNot(table2._data[0], table3._data[0])
self.assertNotEqual(table2._data[0], table3._data[0])
self.assertSequenceEqual(table._data[0], (1, 4, 'a'))
def test_compute_creates_rows(self):
table = Table(self.rows, self.column_names, self.column_types)
table2 = table.compute([
(Formula(self.number_type, lambda r: r['one']), 'new2')
])
table3 = table2.compute([
(Formula(self.number_type, lambda r: r['one']), 'new3')
])
self.assertIsNot(table.rows[0], table2.rows[0])
self.assertNotEqual(table.rows[0], table2.rows[0])
self.assertIsNot(table2.rows[0], table3.rows[0])
self.assertNotEqual(table2.rows[0], table3.rows[0])
self.assertSequenceEqual(table.rows[0], (1, 4, 'a'))
def test_compute_creates_rows(self):
table = Table(self.rows, self.columns)
table2 = table.compute([
(Formula(self.number_type, lambda r: r['one']), 'new2')
])
table3 = table2.compute([
(Formula(self.number_type, lambda r: r['one']), 'new3')
])
self.assertIsNot(table.rows[0], table2.rows[0])
self.assertNotEqual(table.rows[0], table2.rows[0])
self.assertIsNot(table2.rows[0], table3.rows[0])
self.assertNotEqual(table2.rows[0], table3.rows[0])
self.assertSequenceEqual(table.rows[0], (1, 4, 'a'))
def test_percentile_rank(self):
rows = [(n, ) for n in range(1, 1001)]
table = Table(rows, ['ints'], [self.number_type])
new_table = table.compute([('percentiles', PercentileRank('ints'))])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
def test_percentile_rank(self):
rows = [(n,) for n in range(1, 1001)]
table = Table(rows, ["ints"], [self.number_type])
new_table = table.compute([("percentiles", PercentileRank("ints"))])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
def test_percent_zeros(self):
column_names = ['label', 'value']
rows = (('one', 25), ('two', 25), ('three', 0))
new_table = Table(rows, column_names)
new_table = new_table.compute([
('test', Percent('value')),
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('0.0'))
def test_percent_zeros(self):
column_names = ['label', 'value']
rows = (
('one', 25),
('two', 25),
('three', 0)
)
new_table = Table(rows, column_names)
new_table = new_table.compute([
('test', Percent('value')),
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('0.0'))
def test_percentile_rank(self):
rows = [(n,) for n in range(1, 1001)]
table = Table(rows, ['ints'], [self.number_type])
new_table = table.compute([
('percentiles', PercentileRank('ints'))
])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
self.assertIsInstance(new_table.columns['percentiles'][0], Decimal)
self.assertIsInstance(new_table.columns['percentiles'][-1], Decimal)
def test_percent_total_override(self):
new_table = self.table.compute([('test', Percent('two', 5))])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('60.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]),
Decimal('60.0'))
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test', Percent('two', 0))])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test', Percent('two', -1))])
with self.assertRaises(DataTypeError):
zero_table = Table([[0]], ['zero'], [self.number_type])
new_table = zero_table.compute([('test', Percent('zero'))])
def test_change_dates(self):
rows = (("10/4/2015", "10/7/2015"), ("10/2/2015", "9/28/2015"), ("9/28/2015", "9/1/2015"))
date_type = Date()
column_names = ["one", "two"]
column_types = [date_type, date_type]
table = Table(rows, column_names, column_types)
new_table = table.compute([("test", Change("one", "two"))])
self.assertIsNot(new_table, table)
self.assertEqual(len(new_table.rows), 3)
self.assertEqual(len(new_table.columns), 3)
self.assertSequenceEqual(
new_table.rows[0], (datetime.date(2015, 10, 4), datetime.date(2015, 10, 7), datetime.timedelta(days=3))
)
self.assertEqual(new_table.columns["test"][0], datetime.timedelta(days=3))
self.assertEqual(new_table.columns["test"][1], datetime.timedelta(days=-4))
self.assertEqual(new_table.columns["test"][2], datetime.timedelta(days=-27))
def test_percent_total_override(self):
new_table = self.table.compute([
('test', Percent('two', 5))
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('60.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]), Decimal('60.0'))
with self.assertRaises(DataTypeError):
new_table = self.table.compute([
('test', Percent('two', 0))
])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([
('test', Percent('two', -1))
])
with self.assertRaises(DataTypeError):
zero_table = Table([[0]], ['zero'], [self.number_type])
new_table = zero_table.compute([('test', Percent('zero'))])
class TestCompute(AgateTestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 6, None)
)
self.number_type = Number()
self.text_type = Text()
self.column_names = [
'one', 'two', 'three', 'four'
]
self.column_types = [
self.text_type, self.number_type, self.number_type, self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_compute(self):
new_table = self.table.compute([
('test', Formula(self.number_type, lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four', 'test'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number, Number])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5))
self.assertSequenceEqual(new_table.columns['test'], (5, 8, 6, 9))
def test_compute_multiple(self):
new_table = self.table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four', 'number', 'text'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number, Number, Text])
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 5, 'a3'))
self.assertSequenceEqual(new_table.columns['number'], (5, 8, 6, 9))
self.assertSequenceEqual(new_table.columns['text'], ('a3', '-5', 'a4', 'b6'))
def test_compute_with_row_names(self):
table = Table(self.rows, self.column_names, self.column_types, row_names='three')
new_table = table.compute([
('number', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('text', Formula(self.text_type, lambda r: (r['one'] or '-') + six.text_type(r['three'])))
])
self.assertRowNames(new_table, [3, 5, 4, 6])
def test_compute_replace(self):
new_table = self.table.compute([
('two', Formula(self.number_type, lambda r: r['two'] + r['three']))
], replace=True)
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number])
self.assertSequenceEqual(new_table.rows[0], ('a', 5, 3, 4))
self.assertSequenceEqual(new_table.columns['two'], (5, 8, 6, 9))
def test_compute_replace_change_type(self):
new_table = self.table.compute([
('two', Formula(self.text_type, lambda r: 'a'))
], replace=True)
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four'])
self.assertColumnTypes(new_table, [Text, Text, Number, Number])
self.assertSequenceEqual(new_table.rows[0], ('a', 'a', 3, 4))
self.assertSequenceEqual(new_table.columns['two'], ('a', 'a', 'a', 'a'))
def test_compute_replace_partial(self):
new_table = self.table.compute([
('two', Formula(self.number_type, lambda r: r['two'] + r['three'])),
('test', Formula(self.number_type, lambda r: 1))
], replace=True)
self.assertIsNot(new_table, self.table)
self.assertColumnNames(new_table, ['one', 'two', 'three', 'four', 'test'])
self.assertColumnTypes(new_table, [Text, Number, Number, Number, Number])
self.assertSequenceEqual(new_table.rows[0], ('a', 5, 3, 4, 1))
self.assertSequenceEqual(new_table.columns['two'], (5, 8, 6, 9))
class TestTableComputation(unittest.TestCase):
def setUp(self):
self.rows = (('a', 2, 3, 4), (None, 3, 5, None), ('a', 2, 4, None),
('b', 3, 4, None))
self.number_type = Number()
self.text_type = Text()
self.column_names = ['one', 'two', 'three', 'four']
self.column_types = [
self.text_type, self.number_type, self.number_type,
self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_formula(self):
new_table = self.table.compute([
('test', Formula(self.number_type,
lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('5')))
self.assertEqual(new_table.columns['test'][0], Decimal('5'))
self.assertEqual(new_table.columns['test'][1], Decimal('8'))
self.assertEqual(new_table.columns['test'][2], Decimal('6'))
self.assertEqual(new_table.columns['test'][3], Decimal('7'))
def test_formula_invalid(self):
with self.assertRaises(CastError):
new_table = self.table.compute([('test',
Formula(self.number_type,
lambda r: r['one']))])
def test_formula_no_validate(self):
new_table = self.table.compute([('test',
Formula(self.number_type,
lambda r: r['one'],
validate=False))])
# Now everything is screwed up
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), 'a'))
self.assertEqual(new_table.columns['test'][0], 'a')
def test_change(self):
new_table = self.table.compute([('test', Change('two', 'three'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], Decimal('2'))
self.assertEqual(new_table.columns['test'][2], Decimal('2'))
self.assertEqual(new_table.columns['test'][3], Decimal('1'))
def test_change_mixed_types(self):
rows = (('1', '10/24/1978'), ('2', '11/13/1974'))
column_names = ['number', 'date']
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(ValueError):
table.compute([('test', Change('number', 'date'))])
def test_changed_invalid_types(self):
rows = ((False, True), (True, False))
column_names = ['before', 'after']
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([('test', Change('before', 'after'))])
def test_change_nulls(self):
warnings.simplefilter('error')
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([('test', Change('three', 'four'))])
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([('test', Change('four', 'three'))])
warnings.simplefilter('ignore')
new_table = self.table.compute([('test', Change('three', 'four'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_percent_change(self):
new_table = self.table.compute([('test', PercentChange('two',
'three'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
to_one_place = lambda d: d.quantize(Decimal('0.1'))
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('50.0')))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('66.7'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('100.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]),
Decimal('33.3'))
def test_percent_change_invalid_columns(self):
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test',
PercentChange('one', 'three'))])
def test_rank_number(self):
new_table = self.table.compute([('rank', Rank('two'))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_rank_number_reverse(self):
new_table = self.table.compute([('rank', Rank('two', reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_key(self):
new_table = self.table.compute([
('rank', Rank('two', comparer=lambda x, y: int(y - x)))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_reverse_key(self):
new_table = self.table.compute([('rank',
Rank('two',
comparer=lambda x, y: int(y - x),
reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_rank_text(self):
new_table = self.table.compute([('rank', Rank('one'))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 4, 1, 3))
def test_percentile_rank(self):
rows = [(n, ) for n in range(1, 1001)]
table = Table(rows, ['ints'], [self.number_type])
new_table = table.compute([('percentiles', PercentileRank('ints'))])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
class TestTableComputation(unittest.TestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 4, None)
)
self.number_type = Number()
self.text_type = Text()
self.column_names = [
'one', 'two', 'three', 'four'
]
self.column_types = [
self.text_type, self.number_type, self.number_type, self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_formula(self):
new_table = self.table.compute([
('test', Formula(self.number_type, lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('5')))
self.assertEqual(new_table.columns['test'][0], Decimal('5'))
self.assertEqual(new_table.columns['test'][1], Decimal('8'))
self.assertEqual(new_table.columns['test'][2], Decimal('6'))
self.assertEqual(new_table.columns['test'][3], Decimal('7'))
def test_formula_invalid(self):
with self.assertRaises(CastError):
new_table = self.table.compute([ # noqa
('test', Formula(self.number_type, lambda r: r['one']))
])
def test_formula_no_validate(self):
new_table = self.table.compute([
('test', Formula(self.number_type, lambda r: r['one'], cast=False))
])
# Now everything is screwed up
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), 'a'))
self.assertEqual(new_table.columns['test'][0], 'a')
def test_change(self):
new_table = self.table.compute([
('test', Change('two', 'three'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], Decimal('2'))
self.assertEqual(new_table.columns['test'][2], Decimal('2'))
self.assertEqual(new_table.columns['test'][3], Decimal('1'))
def test_change_mixed_types(self):
rows = (
('1', '10/24/1978'),
('2', '11/13/1974')
)
column_names = ['number', 'date']
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([
('test', Change('number', 'date'))
])
def test_changed_invalid_types(self):
rows = (
(False, True),
(True, False)
)
column_names = ['before', 'after']
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([
('test', Change('before', 'after'))
])
def test_change_nulls(self):
warnings.simplefilter('error')
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([
('test', Change('three', 'four'))
])
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([
('test', Change('four', 'three'))
])
warnings.simplefilter('ignore')
new_table = self.table.compute([
('test', Change('three', 'four'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_percent(self):
new_table = self.table.compute([
('test', Percent('two'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('20.0'))
)
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('20.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('30.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('20.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]), Decimal('30.0'))
def test_percent_total_override(self):
new_table = self.table.compute([
('test', Percent('two', 5))
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('60.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]), Decimal('60.0'))
with self.assertRaises(DataTypeError):
new_table = self.table.compute([
('test', Percent('two', 0))
])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([
('test', Percent('two', -1))
])
with self.assertRaises(DataTypeError):
zero_table = Table([[0]], ['zero'], [self.number_type])
new_table = zero_table.compute([('test', Percent('zero'))])
def test_percent_zeros(self):
column_names = ['label', 'value']
rows = (
('one', 25),
('two', 25),
('three', 0)
)
new_table = Table(rows, column_names)
new_table = new_table.compute([
('test', Percent('value')),
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('0.0'))
def test_percent_nulls(self):
new_table = self.table.compute([
('test', Percent('four'))
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(
to_one_place(new_table.columns['test'][0]),
Decimal('100.0')
)
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_percent_change(self):
new_table = self.table.compute([
('test', PercentChange('two', 'three'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('50.0')))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('66.7'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('100.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]), Decimal('33.3'))
def test_percent_change_invalid_columns(self):
with self.assertRaises(DataTypeError):
new_table = self.table.compute([
('test', PercentChange('one', 'three'))
])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([ # noqa
('test', PercentChange('three', 'one'))
])
def test_rank_number(self):
new_table = self.table.compute([
('rank', Rank('two'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
self.assertIsInstance(new_table.columns['rank'][0], Decimal)
def test_rank_number_reverse(self):
new_table = self.table.compute([
('rank', Rank('two', reverse=True))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_key(self):
new_table = self.table.compute([
('rank', Rank('two', comparer=lambda x, y: int(y - x)))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_reverse_key(self):
new_table = self.table.compute([
('rank', Rank('two', comparer=lambda x, y: int(y - x), reverse=True))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_rank_text(self):
new_table = self.table.compute([
('rank', Rank('one'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 4, 1, 3))
def test_percentile_rank(self):
rows = [(n,) for n in range(1, 1001)]
table = Table(rows, ['ints'], [self.number_type])
new_table = table.compute([
('percentiles', PercentileRank('ints'))
])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
self.assertIsInstance(new_table.columns['percentiles'][0], Decimal)
self.assertIsInstance(new_table.columns['percentiles'][-1], Decimal)
def test_percentile_rank_invalid_types(self):
with self.assertRaises(DataTypeError):
self.table.compute([
('test', PercentileRank('one'))
])
class TestTableComputation(unittest.TestCase):
def setUp(self):
self.rows = (("a", 2, 3, 4), (None, 3, 5, None), ("a", 2, 4, None), ("b", 3, 4, None))
self.number_type = Number()
self.text_type = Text()
self.column_names = ["one", "two", "three", "four"]
self.column_types = [self.text_type, self.number_type, self.number_type, self.number_type]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_change(self):
new_table = self.table.compute([("test", Change("two", "three"))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ("a", Decimal("2"), Decimal("3"), Decimal("4"), Decimal("1")))
self.assertEqual(new_table.columns["test"][0], Decimal("1"))
self.assertEqual(new_table.columns["test"][1], Decimal("2"))
self.assertEqual(new_table.columns["test"][2], Decimal("2"))
self.assertEqual(new_table.columns["test"][3], Decimal("1"))
def test_change_mixed_types(self):
rows = (("1", "10/24/1978"), ("2", "11/13/1974"))
column_names = ["number", "date"]
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(ValueError):
table.compute([("test", Change("number", "date"))])
def test_changed_invalid_types(self):
rows = ((False, True), (True, False))
column_names = ["before", "after"]
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([("test", Change("before", "after"))])
def test_change_nulls(self):
warnings.simplefilter("error")
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([("test", Change("three", "four"))])
with self.assertRaises(NullCalculationWarning):
new_table = self.table.compute([("test", Change("four", "three"))])
warnings.simplefilter("ignore")
new_table = self.table.compute([("test", Change("three", "four"))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ("a", Decimal("2"), Decimal("3"), Decimal("4"), Decimal("1")))
self.assertEqual(new_table.columns["test"][0], Decimal("1"))
self.assertEqual(new_table.columns["test"][1], None)
self.assertEqual(new_table.columns["test"][2], None)
self.assertEqual(new_table.columns["test"][3], None)
def test_percent_change(self):
new_table = self.table.compute([("test", PercentChange("two", "three"))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
to_one_place = lambda d: d.quantize(Decimal("0.1"))
self.assertSequenceEqual(new_table.rows[0], ("a", Decimal("2"), Decimal("3"), Decimal("4"), Decimal("50.0")))
self.assertEqual(to_one_place(new_table.columns["test"][0]), Decimal("50.0"))
self.assertEqual(to_one_place(new_table.columns["test"][1]), Decimal("66.7"))
self.assertEqual(to_one_place(new_table.columns["test"][2]), Decimal("100.0"))
self.assertEqual(to_one_place(new_table.columns["test"][3]), Decimal("33.3"))
def test_percent_change_invalid_columns(self):
with self.assertRaises(DataTypeError):
new_table = self.table.compute([("test", PercentChange("one", "three"))])
def test_rank_number(self):
new_table = self.table.compute([("rank", Rank("two"))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns["rank"], (1, 3, 1, 3))
def test_rank_number_reverse(self):
new_table = self.table.compute([("rank", Rank("two", reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns["rank"], (3, 1, 3, 1))
def test_rank_number_key(self):
new_table = self.table.compute([("rank", Rank("two", comparer=lambda x, y: int(y - x)))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns["rank"], (3, 1, 3, 1))
def test_rank_number_reverse_key(self):
new_table = self.table.compute([("rank", Rank("two", comparer=lambda x, y: int(y - x), reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns["rank"], (1, 3, 1, 3))
def test_rank_text(self):
new_table = self.table.compute([("rank", Rank("one"))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns["rank"], (1, 4, 1, 3))
def test_percentile_rank(self):
rows = [(n,) for n in range(1, 1001)]
table = Table(rows, ["ints"], [self.number_type])
new_table = table.compute([("percentiles", PercentileRank("ints"))])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
class TestTableComputation(unittest.TestCase):
def setUp(self):
self.rows = (
('a', 2, 3, 4),
(None, 3, 5, None),
('a', 2, 4, None),
('b', 3, 4, None)
)
self.number_type = NumberType()
self.text_type = TextType()
self.columns = (
('one', self.text_type),
('two', self.number_type),
('three', self.number_type),
('four', self.number_type),
)
self.table = Table(self.rows, self.columns)
def test_change(self):
new_table = self.table.compute([
('test', Change('two', 'three'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
to_one_place = lambda d: d.quantize(Decimal('0.1'))
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], Decimal('2'))
self.assertEqual(new_table.columns['test'][2], Decimal('2'))
self.assertEqual(new_table.columns['test'][3], Decimal('1'))
def test_percent_change(self):
new_table = self.table.compute([
('test', PercentChange('two', 'three'))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
to_one_place = lambda d: d.quantize(Decimal('0.1'))
self.assertSequenceEqual(new_table.rows[0], ('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('50.0')))
self.assertEqual(to_one_place(new_table.columns['test'][0]), Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]), Decimal('66.7'))
self.assertEqual(to_one_place(new_table.columns['test'][2]), Decimal('100.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]), Decimal('33.3'))
def test_percent_change_invalid_columns(self):
with self.assertRaises(UnsupportedComputationError):
new_table = self.table.compute([
('test', PercentChange('one', 'three'))
])
def test_z_scores(self):
new_table = self.table.compute([
('z-scores', ZScores('two'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, -1))
self.assertSequenceEqual(new_table.rows[1], (None, 3, 5, None, 1))
self.assertSequenceEqual(new_table.rows[2], ('a', 2, 4, None, -1))
self.assertSequenceEqual(new_table.rows[3], ('b', 3, 4, None, 1))
self.assertSequenceEqual(new_table.columns['z-scores'],(-1,1,-1,1))
def test_zscores_invalid_column(self):
with self.assertRaises(UnsupportedComputationError):
new_table = self.table.compute([
('test', ZScores('one'))
])
def test_rank_number(self):
new_table = self.table.compute([
('rank', Rank('two'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 1))
self.assertSequenceEqual(new_table.rows[1], (None, 3, 5, None, 3))
self.assertSequenceEqual(new_table.rows[2], ('a', 2, 4, None, 1))
self.assertSequenceEqual(new_table.rows[3], ('b', 3, 4, None, 3))
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_rank_text(self):
new_table = self.table.compute([
('rank', Rank('one'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 1))
self.assertSequenceEqual(new_table.rows[1], (None, 3, 5, None, 4))
self.assertSequenceEqual(new_table.rows[2], ('a', 2, 4, None, 1))
self.assertSequenceEqual(new_table.rows[3], ('b', 3, 4, None, 3))
self.assertSequenceEqual(new_table.columns['rank'], (1, 4, 1, 3))
def test_rank_column_name(self):
new_table = self.table.compute([
('rank', Rank('two'))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.rows[0], ('a', 2, 3, 4, 1))
self.assertSequenceEqual(new_table.rows[1], (None, 3, 5, None, 3))
self.assertSequenceEqual(new_table.rows[2], ('a', 2, 4, None, 1))
self.assertSequenceEqual(new_table.rows[3], ('b', 3, 4, None, 3))
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_percentile_rank(self):
rows = [(n,) for n in range(1, 1001)]
table = Table(rows, (('ints', self.number_type),))
new_table = table.compute([
('percentiles', PercentileRank('ints'))
])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
class TestTableComputation(unittest.TestCase):
def setUp(self):
self.rows = (('a', 2, 3, 4), (None, 3, 5, None), ('a', 2, 4, None),
('b', 3, 4, None))
self.number_type = Number()
self.text_type = Text()
self.column_names = ['one', 'two', 'three', 'four']
self.column_types = [
self.text_type, self.number_type, self.number_type,
self.number_type
]
self.table = Table(self.rows, self.column_names, self.column_types)
def test_formula(self):
new_table = self.table.compute([
('test', Formula(self.number_type,
lambda r: r['two'] + r['three']))
])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('5')))
self.assertEqual(new_table.columns['test'][0], Decimal('5'))
self.assertEqual(new_table.columns['test'][1], Decimal('8'))
self.assertEqual(new_table.columns['test'][2], Decimal('6'))
self.assertEqual(new_table.columns['test'][3], Decimal('7'))
def test_formula_invalid(self):
with self.assertRaises(CastError):
new_table = self.table.compute([ # noqa
('test', Formula(self.number_type, lambda r: r['one']))
])
def test_formula_no_validate(self):
new_table = self.table.compute([('test',
Formula(self.number_type,
lambda r: r['one'],
cast=False))])
# Now everything is screwed up
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), 'a'))
self.assertEqual(new_table.columns['test'][0], 'a')
def test_change(self):
new_table = self.table.compute([('test', Change('two', 'three'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], Decimal('2'))
self.assertEqual(new_table.columns['test'][2], Decimal('2'))
self.assertEqual(new_table.columns['test'][3], Decimal('1'))
def test_change_mixed_types(self):
rows = (('1', '10/24/1978'), ('2', '11/13/1974'))
column_names = ['number', 'date']
column_types = [Number(), Date()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([('test', Change('number', 'date'))])
def test_changed_invalid_types(self):
rows = ((False, True), (True, False))
column_names = ['before', 'after']
column_types = [Boolean(), Boolean()]
table = Table(rows, column_names, column_types)
with self.assertRaises(DataTypeError):
table.compute([('test', Change('before', 'after'))])
def test_change_nulls(self):
with self.assertWarns(NullCalculationWarning):
new_table = self.table.compute([('test', Change('three', 'four'))])
with self.assertWarns(NullCalculationWarning):
new_table = self.table.compute([('test', Change('four', 'three'))])
warnings.simplefilter('ignore')
try:
new_table = self.table.compute([('test', Change('three', 'four'))])
finally:
warnings.resetwarnings()
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('1')))
self.assertEqual(new_table.columns['test'][0], Decimal('1'))
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_percent(self):
new_table = self.table.compute([('test', Percent('two'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('20.0')))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('20.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('30.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('20.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]),
Decimal('30.0'))
def test_percent_total_override(self):
new_table = self.table.compute([('test', Percent('two', 5))])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('60.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('40.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]),
Decimal('60.0'))
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test', Percent('two', 0))])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test', Percent('two', -1))])
with self.assertRaises(DataTypeError):
zero_table = Table([[0]], ['zero'], [self.number_type])
new_table = zero_table.compute([('test', Percent('zero'))])
def test_percent_zeros(self):
column_names = ['label', 'value']
rows = (('one', 25), ('two', 25), ('three', 0))
new_table = Table(rows, column_names)
new_table = new_table.compute([
('test', Percent('value')),
])
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('0.0'))
def test_percent_nulls(self):
warnings.simplefilter('ignore')
try:
new_table = self.table.compute([('test', Percent('four'))])
finally:
warnings.resetwarnings()
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('100.0'))
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_percent_change(self):
new_table = self.table.compute([('test', PercentChange('two',
'three'))])
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertSequenceEqual(
new_table.rows[0],
('a', Decimal('2'), Decimal('3'), Decimal('4'), Decimal('50.0')))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('50.0'))
self.assertEqual(to_one_place(new_table.columns['test'][1]),
Decimal('66.7'))
self.assertEqual(to_one_place(new_table.columns['test'][2]),
Decimal('100.0'))
self.assertEqual(to_one_place(new_table.columns['test'][3]),
Decimal('33.3'))
def test_percent_change_invalid_columns(self):
with self.assertRaises(DataTypeError):
new_table = self.table.compute([('test',
PercentChange('one', 'three'))])
with self.assertRaises(DataTypeError):
new_table = self.table.compute([ # noqa
('test', PercentChange('three', 'one'))
])
def test_percent_change_nulls(self):
with self.assertWarns(NullCalculationWarning):
new_table = self.table.compute([('test',
PercentChange('three', 'four'))])
with self.assertWarns(NullCalculationWarning):
new_table = self.table.compute([('test',
PercentChange('four', 'three'))])
warnings.simplefilter('ignore')
try:
new_table = self.table.compute([('test',
PercentChange('three', 'four'))])
finally:
warnings.resetwarnings()
self.assertIsNot(new_table, self.table)
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
def to_one_place(d):
return d.quantize(Decimal('0.1'))
self.assertSequenceEqual(new_table.rows[2],
('a', Decimal('2'), Decimal('4'), None, None))
self.assertEqual(to_one_place(new_table.columns['test'][0]),
Decimal('33.3'))
self.assertEqual(new_table.columns['test'][1], None)
self.assertEqual(new_table.columns['test'][2], None)
self.assertEqual(new_table.columns['test'][3], None)
def test_rank_number(self):
new_table = self.table.compute([('rank', Rank('two'))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
self.assertIsInstance(new_table.columns['rank'][0], Decimal)
def test_rank_number_reverse(self):
new_table = self.table.compute([('rank', Rank('two', reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_key(self):
new_table = self.table.compute([
('rank', Rank('two', comparer=lambda x, y: int(y - x)))
])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (3, 1, 3, 1))
def test_rank_number_reverse_key(self):
new_table = self.table.compute([('rank',
Rank('two',
comparer=lambda x, y: int(y - x),
reverse=True))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 3, 1, 3))
def test_rank_text(self):
new_table = self.table.compute([('rank', Rank('one'))])
self.assertEqual(len(new_table.rows), 4)
self.assertEqual(len(new_table.columns), 5)
self.assertSequenceEqual(new_table.columns['rank'], (1, 4, 1, 3))
def test_percentile_rank(self):
rows = [(n, ) for n in range(1, 1001)]
table = Table(rows, ['ints'], [self.number_type])
new_table = table.compute([('percentiles', PercentileRank('ints'))])
self.assertEqual(len(new_table.rows), 1000)
self.assertEqual(len(new_table.columns), 2)
self.assertSequenceEqual(new_table.rows[0], (1, 0))
self.assertSequenceEqual(new_table.rows[50], (51, 5))
self.assertSequenceEqual(new_table.rows[499], (500, 49))
self.assertSequenceEqual(new_table.rows[500], (501, 50))
self.assertSequenceEqual(new_table.rows[998], (999, 99))
self.assertSequenceEqual(new_table.rows[999], (1000, 100))
self.assertIsInstance(new_table.columns['percentiles'][0], Decimal)
self.assertIsInstance(new_table.columns['percentiles'][-1], Decimal)
def test_percentile_rank_invalid_types(self):
with self.assertRaises(DataTypeError):
self.table.compute([('test', PercentileRank('one'))])
def test_slug(self):
rows = (('hello world', 2), ('Ab*c #e', 2), ('He11O W0rld', 3))
expected = ['hello_world', 'ab_c_e', 'he11o_w0rld']
table = Table(rows, ['one', 'two'],
[self.text_type, self.number_type]).compute([
('slugs', Slug('one'))
])
self.assertSequenceEqual(table.columns['slugs'], expected)
def test_slug_column_name_sequence(self):
rows = (('hello world', 2, 'Ab*c #e'), ('Ab*c #e', 2, 'He11O W0rld'),
('He11O W0rld', 3, 'hello world'))
expected = [
'hello_world_ab_c_e', 'ab_c_e_he11o_w0rld',
'he11o_w0rld_hello_world'
]
table1 = Table(rows, ['one', 'two', 'three'],
[self.text_type, self.number_type, self.text_type])
table2 = table1.compute([('slugs', Slug(['one', 'three']))])
self.assertSequenceEqual(table2.columns['slugs'], expected)
def test_slug_ensure_unique(self):
rows = (('hello world', 2), ('Ab*c #e', 2), ('He11O W0rld', 3),
('HellO WOrld ', 3))
expected = ['hello_world', 'ab_c_e', 'he11o_w0rld', 'hello_world_2']
table = Table(rows, ['one', 'two'],
[self.text_type, self.number_type]).compute([
('slugs', Slug('one', ensure_unique=True))
])
self.assertSequenceEqual(table.columns['slugs'], expected)
def test_slug_contains_null_error(self):
with self.assertRaises(ValueError):
self.table.compute([('slugs', Slug('one', ensure_unique=True))])
