class ContextTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), periods=3, freq=datetools.yearEnd) self.ctx = MDFContext() def test_shift(self): # C yields a value based on shifted contexts res = [] for t in self.daterange: self.ctx.set_date(t) res.append(self.ctx[C]) assert_array_almost_equal(res, [(1,2,3), (3,5,7), (6,9,12)]) def test_shift2(self): # C yields a value based on shifted contexts res = [] for t in self.daterange: self.ctx.set_date(t) res.append(self.ctx[D]) assert_array_almost_equal(res, [(1,2,3), (3,5,7), (6,9,12)])
class ExceptionTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext() def test_exception_1(self): # A should raise an exception if A is not True self.ctx[A] = False self.assertRaises(TestException, self.ctx.get_value, B) # when called again the exception should be re-raised self.assertRaises(TestException, self.ctx.get_value, B) # setting A should cause B to return True self.ctx[A] = True self.assertTrue(self.ctx[B]) def test_exception_2(self): # C should raise an exception while 'now' is before 2001 self.ctx.set_date(datetime(2000, 12, 31)) self.assertRaises(TestException, self.ctx.get_value, C) self.ctx.set_date(datetime(2001, 1, 1)) self.assertTrue(self.ctx[C])
class ContextTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), periods=3, freq=datetools.yearEnd) self.ctx = MDFContext() def test_shift(self): # C yields a value based on shifted contexts res = [] for t in self.daterange: self.ctx.set_date(t) res.append(self.ctx[C]) assert_array_almost_equal(res, [(1, 2, 3), (3, 5, 7), (6, 9, 12)]) def test_shift2(self): # C yields a value based on shifted contexts res = [] for t in self.daterange: self.ctx.set_date(t) res.append(self.ctx[D]) assert_array_almost_equal(res, [(1, 2, 3), (3, 5, 7), (6, 9, 12)])
class ClsNodeTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), datetime(1970, 1, 10)) self.ctx = MDFContext() self.ctx[_TestNodes.C] = 10 self.ctx[_TestNodes.D] = 20 def test_queuenode(self): self._run(_TestNodes.queue_output) queue = self.ctx[_TestNodes.queue_output] self.assertEqual(len(queue), len(self.daterange)) def test_nansumnode(self): self._run(_TestNodes.nansum_output) nansum = self.ctx[_TestNodes.nansum_output] self.assertEqual(nansum, 812) def test_cumprodnode(self): self._run(_TestNodes.cumprod_output) cumprod = self.ctx[_TestNodes.cumprod_output] self.assertEqual(cumprod, 14201189062704000) def test_subclass(self): base_a = self.ctx[_TestNodes.A] sub_a = self.ctx[SubClass.A] self.assertEqual(base_a, 200) self.assertEqual(sub_a, 30) self._run(_TestNodes.cumprod_output, SubClass.cumprod_output) base_cumprod = self.ctx[_TestNodes.cumprod_output] sub_cumprod = self.ctx[SubClass.cumprod_output] self.assertEqual(base_cumprod, 14201189062704000) self.assertEqual(sub_cumprod, 42072307200) def test_nodenames(self): self.assertNotEqual(SubClass.A.name, _TestNodes.A.name) def test_queue_size(self): self._run( _TestNodes.queue_size_test, # check basic queue size _TestNodes.queue_size_test2, # check evalnode queue size SubClass.queue_size_test2) # check overriding of queue size self.assertEqual(len(self.ctx[_TestNodes.queue_size_test]), 2) self.assertEqual(len(self.ctx[_TestNodes.queue_size_test2]), 3) self.assertEqual(len(self.ctx[SubClass.queue_size_test2]), 4) def test_datanode(self): self._run(_TestNodes.df_data, _TestNodes.df_filter) self.assertEqual(self.ctx[_TestNodes.df_data]["A"], len(self.daterange) - 1) self.assertTrue(self.ctx[_TestNodes.df_filter]) self.ctx.set_date(datetime(1990, 1, 1)) self.assertFalse(self.ctx[_TestNodes.df_filter]) def _run(self, *nodes): for t in self.daterange: self.ctx.set_date(t) for node in nodes: self.ctx[node]
class NodeTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), datetime(1970, 1, 10)) self.ctx = MDFContext() self.ctx[params.C] = 10 self.ctx[params.D] = 20 def test_queuenode(self): self._run(queue_output) queue = self.ctx[queue_output] self.assertEqual(len(queue), len(self.daterange)) def test_queueyield(self): self._run(queue_yield) queue = self.ctx[queue_yield] self.assertEqual(len(queue), len(self.daterange)) def test_queue_filter(self): self._run(queue_filter_test) queue = self.ctx[queue_filter_test] self.assertEqual(list(queue), [0] * (len(self.daterange) - 1)) @staticmethod def diff_dfs(lhs_df, rhs_df, tolerance): diffs = np.abs(lhs_df - rhs_df) mask = (diffs > tolerance).values mask &= ~(np.isnan(lhs_df) and np.isnan(rhs_df)).values mask |= np.isnan(lhs_df).values & ~np.isnan(rhs_df).values mask |= np.isnan(rhs_df).values & ~np.isnan(lhs_df).values return mask.any() def test_nansumnode(self): self._run(nansum_output) nansum = self.ctx[nansum_output] self.assertEqual(nansum, 812) def test_cumprodnode(self): self._run(cumprod_output) cumprod = self.ctx[cumprod_output] self.assertEqual(cumprod, 14201189062704000) def test_delaynode(self): self._run(DelayNodeTest.delay_test, DelayNodeTest.delay_test_lazy) value = self.ctx[DelayNodeTest.delay_test] value_lazy = self.ctx[DelayNodeTest.delay_test_lazy] self.assertEqual(list(value), range(1, len(self.daterange) + 1)) self.assertEqual(list(value_lazy), range(1, len(self.daterange) + 1)) def test_ffillnode(self): self._run(ffill_queue) value = self.ctx[ffill_queue] self.assertEqual(tuple(value), (0.0, 0.0, 2.0, 2.0, 4.0, 4.0, 6.0)) def test_ffill_array(self): self._run(ffill_array_test) value = self.ctx[ffill_array_test] unfilled_value = self.ctx[ffill_array_test_not_filled] self.assertTrue(np.isnan(unfilled_value).all()) self.assertEquals(value.tolist(), [10.0, 10.0, 10.0, 10.0, 10.0]) def test_datanode_ffill(self): data = pd.Series(range(len(self.daterange)), self.daterange, dtype=float) data = data[[bool(i % 2) for i in xrange(len(data.index))]] expected = data.reindex(self.daterange, method="ffill") expected[np.isnan(expected)] = np.inf node = datanode("test_datanode_ffill", data, ffill=True, missing_value=np.inf) qnode = node.queuenode() self._run(qnode) value = self.ctx[qnode] self.assertEquals(list(value), expected.values.tolist()) def test_lookahead_node(self): B_queue = B.queuenode() B_lookahead = B.lookaheadnode(periods=len(self.daterange)) self.ctx.set_date(self.daterange[0]) actual = self.ctx[B_lookahead] self._run(B_queue) expected = self.ctx[B_queue] self.assertEquals(actual.values.tolist(), list(expected)) self.assertEquals(actual.index.tolist(), list(self.daterange)) def test_apply_node(self): actual_node = A.applynode(func=operator.add, args=(B,)).queuenode() expected_node = A_plus_B.queuenode() self._run(actual_node, expected_node) actual = self.ctx[actual_node] expected = self.ctx[expected_node] self.assertEquals(actual, expected) def test_binary_operators_with_constant(self): self._test(Counter, [-2.0, -1.5, -1.0, -0.5, 0.5, 1.0, 1.5]) self._test(Counter + 0.2, [-1.8, -1.3, -0.8, -0.3, 0.7, 1.2, 1.7]) self._test(Counter - 0.2, [-2.2, -1.7, -1.2, -0.7, 0.3, 0.8, 1.3]) self._test(Counter * 2.0, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(Counter / 0.5, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(0.2 + Counter, [-1.8, -1.3, -0.8, -0.3, 0.7, 1.2, 1.7]) self._test(1.0 - Counter, [3.0, 2.5, 2.0, 1.5, 0.5, 0.0, -0.5]) self._test(2.0 * Counter, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test( 12 / (Counter + 0.25), [-6.8571428571428568, -9.6000000000000014, -16.0, -48.0, 16.0, 9.6000000000000014, 6.8571428571428568], ) def test_binary_operators_with_node(self): self._test(Counter + Counter, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(Counter - Counter, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) self._test(Counter * Counter, [4.0, 2.25, 1.0, 0.25, 0.25, 1.0, 2.25]) self._test(Counter / Counter, [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]) def _test(self, node, expected_values): values = node.queuenode() self._run(values) actual = self.ctx[values] self.assertEquals(list(actual), expected_values) def _run_for_daterange(self, date_range, *nodes): for t in date_range: self.ctx.set_date(t) for node in nodes: self.ctx[node] def _run(self, *nodes): self._run_for_daterange(self.daterange, *nodes)
class NodeTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), datetime(1970, 1, 10)) self.ctx = MDFContext() self.ctx[params.C] = 10 self.ctx[params.D] = 20 def test_queuenode(self): self._run(queue_output) queue = self.ctx[queue_output] self.assertEqual(len(queue), len(self.daterange)) def test_queueyield(self): self._run(queue_yield) queue = self.ctx[queue_yield] self.assertEqual(len(queue), len(self.daterange)) def test_queue_filter(self): self._run(queue_filter_test) queue = self.ctx[queue_filter_test] self.assertEqual(list(queue), [0] * (len(self.daterange) - 1)) @staticmethod def diff_dfs(lhs_df, rhs_df, tolerance): diffs = np.abs(lhs_df - rhs_df) mask = (diffs > tolerance).values mask &= ~(np.isnan(lhs_df) and np.isnan(rhs_df)).values mask |= np.isnan(lhs_df).values & ~np.isnan(rhs_df).values mask |= np.isnan(rhs_df).values & ~np.isnan(lhs_df).values return mask.any() def test_nansumnode(self): self._run(nansum_output) nansum = self.ctx[nansum_output] self.assertEqual(nansum, 812) def test_cumprodnode(self): self._run(cumprod_output) cumprod = self.ctx[cumprod_output] self.assertEqual(cumprod, 14201189062704000) def test_delaynode(self): self._run(DelayNodeTest.delay_test, DelayNodeTest.delay_test_lazy) value = self.ctx[DelayNodeTest.delay_test] value_lazy = self.ctx[DelayNodeTest.delay_test_lazy] self.assertEqual(list(value), list(range(1, len(self.daterange)+1))) self.assertEqual(list(value_lazy), list(range(1, len(self.daterange)+1))) def test_ffillnode(self): self._run(ffill_queue) value = self.ctx[ffill_queue] self.assertEqual(tuple(value), (0.0, 0.0, 2.0, 2.0, 4.0, 4.0, 6.0)) def test_ffill_array(self): self._run(ffill_array_test) value = self.ctx[ffill_array_test] unfilled_value = self.ctx[ffill_array_test_not_filled] self.assertTrue(np.isnan(unfilled_value).all()) self.assertEquals(value.tolist(), [10., 10., 10., 10., 10.]) def test_datanode_ffill(self): data = pd.Series(range(len(self.daterange)), self.daterange, dtype=float) data = data[[bool(i % 2) for i in range(len(data.index))]] expected = data.reindex(self.daterange, method="ffill") expected[np.isnan(expected)] = np.inf node = datanode("test_datanode_ffill", data, ffill=True, missing_value=np.inf) qnode = node.queuenode() self._run(qnode) value = self.ctx[qnode] self.assertEquals(list(value), expected.values.tolist()) def test_lookahead_node(self): B_queue = B.queuenode() B_lookahead = B.lookaheadnode(periods=len(self.daterange)) self.ctx.set_date(self.daterange[0]) actual = self.ctx[B_lookahead] self._run(B_queue) expected = self.ctx[B_queue] self.assertEquals(actual.values.tolist(), list(expected)) self.assertEquals(actual.index.tolist(), list(self.daterange)) def test_apply_node(self): actual_node = A.applynode(func=operator.add, args=(B,)).queuenode() expected_node = A_plus_B.queuenode() self._run(actual_node, expected_node) actual = self.ctx[actual_node] expected = self.ctx[expected_node] self.assertEquals(actual, expected) def test_binary_operators_with_constant(self): self._test(Counter, [-2.0, -1.5, -1.0, -0.5, 0.5, 1.0, 1.5]) self._test(Counter + 0.2, [-1.8, -1.3, -0.8, -0.3, 0.7, 1.2, 1.7]) self._test(Counter - 0.2, [-2.2, -1.7, -1.2, -0.7, 0.3, 0.8, 1.3]) self._test(Counter * 2.0, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(Counter / 0.5, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(0.2 + Counter, [-1.8, -1.3, -0.8, -0.3, 0.7, 1.2, 1.7]) self._test(1.0 - Counter, [ 3.0, 2.5, 2.0, 1.5, 0.5, 0.0, -0.5]) self._test(2.0 * Counter, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(12 / (Counter+.25), [-6.8571428571428568, -9.6000000000000014, -16.0, -48.0, 16.0, 9.6000000000000014, 6.8571428571428568]) def test_binary_operators_with_node(self): self._test(Counter + Counter, [-4.0, -3.0, -2.0, -1.0, 1.0, 2.0, 3.0]) self._test(Counter - Counter, [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]) self._test(Counter * Counter, [ 4.0, 2.25, 1.0, 0.25, 0.25, 1.0, 2.25]) self._test(Counter / Counter, [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]) def _test(self, node, expected_values): values = node.queuenode() self._run(values) actual = self.ctx[values] self.assertEquals(list(actual), expected_values) def _run_for_daterange(self, date_range, *nodes): for t in date_range: self.ctx.set_date(t) for node in nodes: self.ctx[node] def _run(self, *nodes): self._run_for_daterange(self.daterange, *nodes)
class ClsNodeTest(unittest.TestCase): def setUp(self): self.daterange = pd.bdate_range(datetime(1970, 1, 1), datetime(1970, 1, 10)) self.ctx = MDFContext() self.ctx[_TestNodes.C] = 10 self.ctx[_TestNodes.D] = 20 def test_queuenode(self): self._run(_TestNodes.queue_output) queue = self.ctx[_TestNodes.queue_output] self.assertEqual(len(queue), len(self.daterange)) def test_nansumnode(self): self._run(_TestNodes.nansum_output) nansum = self.ctx[_TestNodes.nansum_output] self.assertEqual(nansum, 812) def test_cumprodnode(self): self._run(_TestNodes.cumprod_output) cumprod = self.ctx[_TestNodes.cumprod_output] self.assertEqual(cumprod, 14201189062704000) def test_subclass(self): base_a = self.ctx[_TestNodes.A] sub_a = self.ctx[SubClass.A] self.assertEqual(base_a, 200) self.assertEqual(sub_a, 30) self._run(_TestNodes.cumprod_output, SubClass.cumprod_output) base_cumprod = self.ctx[_TestNodes.cumprod_output] sub_cumprod = self.ctx[SubClass.cumprod_output] self.assertEqual(base_cumprod, 14201189062704000) self.assertEqual(sub_cumprod, 42072307200) def test_nodenames(self): self.assertNotEqual(SubClass.A.name, _TestNodes.A.name) def test_queue_size(self): self._run(_TestNodes.queue_size_test, # check basic queue size _TestNodes.queue_size_test2, # check evalnode queue size SubClass.queue_size_test2) # check overriding of queue size self.assertEqual(len(self.ctx[_TestNodes.queue_size_test]), 2) self.assertEqual(len(self.ctx[_TestNodes.queue_size_test2]), 3) self.assertEqual(len(self.ctx[SubClass.queue_size_test2]), 4) def test_datanode(self): self._run(_TestNodes.df_data, _TestNodes.df_filter) self.assertEqual(self.ctx[_TestNodes.df_data]["A"], len(self.daterange) - 1) self.assertTrue(self.ctx[_TestNodes.df_filter]) self.ctx.set_date(datetime(1990, 1, 1)) self.assertFalse(self.ctx[_TestNodes.df_filter]) def _run(self, *nodes): for t in self.daterange: self.ctx.set_date(t) for node in nodes: self.ctx[node]
class NodeFilterTest(unittest.TestCase): def setUp(self): self.ctx = MDFContext(index[0]) def test_queue(self): actual = self._run(datanode.queuenode(as_list=True)) self.assertEqual(actual.tolist(), queue_expected) actual = self._run(datanode.queuenode(filter=filternode, as_list=True)) self.assertEqual(actual.tolist(), queue_filtered_expected) def test_delay(self): actual = self._run(datanode.delaynode(periods=1, initial_value=np.nan)) self.assertEqual(_normalize(actual), _normalize(delay_expected)) actual = self._run(datanode.delaynode(periods=1, initial_value=np.nan, filter=filternode)) self.assertEqual(_normalize(actual), _normalize(delay_filtered_expected)) def test_delay_df(self): actual = self._run(dfnode.delaynode(periods=1, initial_value=np.nan)) self.assertEqual(_normalize(actual), _normalize(delay_df_expected)) actual = self._run(dfnode.delaynode(periods=1, initial_value=np.nan, filter=filternode)) self.assertEqual(_normalize(actual), _normalize(delay_df_filtered_expected)) def test_nansum(self): actual = self._run(datanode.nansumnode()) self.assertEqual(_normalize(actual), _normalize(nansum_expected)) actual = self._run(datanode.nansumnode(filter=filternode)) self.assertEqual(_normalize(actual), _normalize(nansum_filtered_expected)) def test_nansum_df(self): actual = self._run(dfnode.nansumnode()) self.assertEqual(_normalize(actual), _normalize(nansum_df_expected)) actual = self._run(dfnode.nansumnode(filter=filternode)) self.assertEqual(_normalize(actual), _normalize(nansum_df_filtered_expected)) def test_cumprod(self): actual = self._run(datanode.cumprodnode()) self.assertEqual(_normalize(actual), _normalize(cumprod_expected)) actual = self._run(datanode.cumprodnode(filter=filternode)) self.assertEqual(_normalize(actual), _normalize(cumprod_filtered_expected)) def test_cumprod_df(self): actual = self._run(dfnode.cumprodnode()) self.assertEqual(_normalize(actual), _normalize(cumprod_df_expected)) actual = self._run(dfnode.cumprodnode(filter=filternode)) self.assertEqual(_normalize(actual), _normalize(cumprod_df_filtered_expected)) def _run(self, node): result = [] for t in index: self.ctx.set_date(t) result.append(self.ctx[node]) if isinstance(result[0], pa.Series): return pa.DataFrame(result, index=index) return pa.Series(result, index, dtype=object)