def test_read_from_asset_finder(self): sids = list(range(8)) exchange_names = [ 'NEW YORK STOCK EXCHANGE', 'NEW YORK STOCK EXCHANGE', 'NASDAQ STOCK MARKET', 'NASDAQ STOCK MARKET', 'TOKYO STOCK EXCHANGE', 'TOKYO STOCK EXCHANGE', 'OSAKA STOCK EXCHANGE', 'OSAKA STOCK EXCHANGE', ] equities = pd.DataFrame({ 'sid': sids, 'real_sid': [str(sid) for sid in sids], 'currency': ['USD'] * len(sids), 'exchange': exchange_names, 'symbol': [chr(65 + sid) for sid in sids], }) exchange_infos = [ ExchangeInfo('NEW YORK STOCK EXCHANGE', 'NYSE', 'US'), ExchangeInfo('NASDAQ STOCK MARKET', 'NYSE', 'US'), ExchangeInfo('TOKYO STOCK EXCHANGE', 'JPX', 'JP'), ExchangeInfo('OSAKA STOCK EXCHANGE', 'JPX', 'JP'), ] exchange_info_table = pd.DataFrame( [(info.name, info.canonical_name, info.country_code) for info in exchange_infos], columns=['exchange', 'canonical_name', 'country_code'], ) expected_exchange_info_map = { info.name: info for info in exchange_infos } ctx = tmp_asset_finder( equities=equities, exchanges=exchange_info_table, ) with ctx as af: actual_exchange_info_map = af.exchange_info assets = af.retrieve_all(sids) assert_equal(actual_exchange_info_map, expected_exchange_info_map) for asset in assets: expected_exchange_info = expected_exchange_info_map[exchange_names[ asset.sid]] assert_equal(asset.exchange_info, expected_exchange_info)
def test_non_existent_asset(self): """ Test that indexing into a term with a non-existent asset raises the proper exception. """ my_asset = Asset( 0, exchange_info=ExchangeInfo('TEST FULL', 'TEST', 'US'), ) returns = Returns(window_length=2, inputs=[self.col]) returns_slice = returns[my_asset] class UsesSlicedInput(CustomFactor): window_length = 2 inputs = [returns_slice] def compute(self, today, assets, out, returns_slice): pass with self.assertRaises(NonExistentAssetInTimeFrame): self.run_pipeline( Pipeline(columns={'uses_sliced_input': UsesSlicedInput()}), self.pipeline_start_date, self.pipeline_end_date, )
def test_require_length_greater_than_one(self): my_asset = Equity( 0, exchange_info=ExchangeInfo('TEST', 'TEST FULL', 'US'), ) with self.assertRaises(ValueError): RollingPearsonOfReturns( target=my_asset, returns_length=3, correlation_length=1, ) with self.assertRaises(ValueError): RollingSpearmanOfReturns( target=my_asset, returns_length=3, correlation_length=1, ) with self.assertRaises(ValueError): RollingLinearRegressionOfReturns( target=my_asset, returns_length=3, regression_length=1, )
def test_correlation_and_regression_with_bad_asset(self): """ Test that `RollingPearsonOfReturns`, `RollingSpearmanOfReturns` and `RollingLinearRegressionOfReturns` raise the proper exception when given a nonexistent target asset. """ my_asset = Equity( 0, real_sid='0', currency='USD', exchange_info=ExchangeInfo('TEST', 'TEST FULL', 'US'), ) start_date = self.pipeline_start_date end_date = self.pipeline_end_date run_pipeline = self.run_pipeline # This filter is arbitrary; the important thing is that we test each # factor both with and without a specified mask. my_asset_filter = AssetID().eq(1) for mask in (NotSpecified, my_asset_filter): pearson_factor = RollingPearsonOfReturns( target=my_asset, returns_length=3, correlation_length=3, mask=mask, ) spearman_factor = RollingSpearmanOfReturns( target=my_asset, returns_length=3, correlation_length=3, mask=mask, ) regression_factor = RollingLinearRegressionOfReturns( target=my_asset, returns_length=3, regression_length=3, mask=mask, ) with self.assertRaises(NonExistentAssetInTimeFrame): run_pipeline( Pipeline(columns={'pearson_factor': pearson_factor}), start_date, end_date, ) with self.assertRaises(NonExistentAssetInTimeFrame): run_pipeline( Pipeline(columns={'spearman_factor': spearman_factor}), start_date, end_date, ) with self.assertRaises(NonExistentAssetInTimeFrame): run_pipeline( Pipeline(columns={'regression_factor': regression_factor}), start_date, end_date, )
def test_equality(self): a = ExchangeInfo('FULL NAME', 'E', 'US') b = ExchangeInfo('FULL NAME', 'E', 'US') assert_equal(a, b) # same full name but different canonical name c = ExchangeInfo('FULL NAME', 'NOT E', 'US') assert_not_equal(c, a) # same canonical name but different full name d = ExchangeInfo('DIFFERENT FULL NAME', 'E', 'US') assert_not_equal(d, a) # same names but different country e = ExchangeInfo('FULL NAME', 'E', 'JP') assert_not_equal(e, a)
def test_transaction_repr(): dt = pd.Timestamp("2017-01-01") asset = Equity( 1, exchange_info=ExchangeInfo("test", "test full", "US"), ) txn = Transaction(asset, amount=100, dt=dt, price=10, order_id=0) expected = ("Transaction(asset=Equity(1), dt=2017-01-01 00:00:00," " amount=100, price=10)") assert repr(txn) == expected
def test_transaction_repr(self): dt = pd.Timestamp('2017-01-01') asset = Equity( 1, exchange_info=ExchangeInfo('test', 'test full', 'US'), ) txn = Transaction(asset, amount=100, dt=dt, price=10, order_id=0) expected = ("Transaction(asset=Equity(1), dt=2017-01-01 00:00:00," " amount=100, price=10)") self.assertEqual(repr(txn), expected)
def test_asset_object(self): the_asset = Asset(5061, real_sid='5061', exchange_info=ExchangeInfo('bar', 'bar', '??'), currency='USD') self.assertEqual({5061: 'foo'}[the_asset], 'foo') self.assertEqual(the_asset, 5061) self.assertEqual(5061, the_asset) self.assertEqual(the_asset, the_asset) self.assertEqual(int(the_asset), 5061) self.assertEqual(str(the_asset), 'Asset(5061)')
def test_instance_caching_of_slices(self): my_asset = Asset( 1, exchange_info=ExchangeInfo('TEST FULL', 'TEST', 'US'), ) f = GenericCustomFactor() f_slice = f[my_asset] self.assertIs(f_slice, Slice(GenericCustomFactor(), my_asset)) f = GenericFilter() f_slice = f[my_asset] self.assertIs(f_slice, Slice(GenericFilter(), my_asset)) c = GenericClassifier() c_slice = c[my_asset] self.assertIs(c_slice, Slice(GenericClassifier(), my_asset))
def test_instance_caching_of_slices(self): my_asset = Asset(1, real_sid='1', exchange_info=ExchangeInfo('TEST FULL', 'TEST', 'US'), currency='USD') f = GenericCustomFactor() f_slice = f[my_asset] self.assertIs(f_slice, type(f_slice)(GenericCustomFactor(), my_asset)) filt = GenericFilter() filt_slice = filt[my_asset] self.assertIs(filt_slice, type(filt_slice)(GenericFilter(), my_asset)) c = GenericClassifier() c_slice = c[my_asset] self.assertIs(c_slice, type(c_slice)(GenericClassifier(), my_asset))
def test_instance_caching_of_slices(self): my_asset = Asset( 1, exchange_info=ExchangeInfo("TEST FULL", "TEST", "US"), ) f = GenericCustomFactor() f_slice = f[my_asset] self.assertIs(f_slice, type(f_slice)(GenericCustomFactor(), my_asset)) filt = GenericFilter() filt_slice = filt[my_asset] self.assertIs(filt_slice, type(filt_slice)(GenericFilter(), my_asset)) c = GenericClassifier() c_slice = c[my_asset] self.assertIs(c_slice, type(c_slice)(GenericClassifier(), my_asset))
def test_transaction_repr(self): dt = pd.Timestamp('2017-01-01') asset = Equity( 1, exchange_info=ExchangeInfo('test', 'test full', 'US'), ) pos = Position(asset, amount=0, cost_basis=0.0, last_sale_price=0.0, last_sale_date=dt) print(pos) raise # expected = ( # "Transaction(asset=Equity(1), dt=2017-01-01 00:00:00," # " amount=100, price=10)" # ) expected = "" self.assertEqual(repr(pos), expected)
def test_write_direct(self): # don't include anything with a default to test that those work. equities = pd.DataFrame({ 'sid': [0, 1], 'real_sid': ['0', '1'], 'currency': ['USD', 'CAD'], 'asset_name': ['Ayy Inc.', 'Lmao LP'], # the full exchange name 'exchange': ['NYSE', 'TSE'], }) equity_symbol_mappings = pd.DataFrame({ 'sid': [0, 1], 'symbol': ['AYY', 'LMAO'], 'company_symbol': ['AYY', 'LMAO'], 'share_class_symbol': ['', ''], }) exchanges = pd.DataFrame({ 'exchange': ['NYSE', 'TSE'], 'country_code': ['US', 'JP'], }) self.writer.write_direct( equities=equities, equity_symbol_mappings=equity_symbol_mappings, exchanges=exchanges, ) reader = self.new_asset_finder() equities = reader.retrieve_all(reader.sids) expected_equities = [ Equity( 0, '0', ExchangeInfo('NYSE', 'NYSE', 'US'), currency='USD', symbol='AYY', asset_name='Ayy Inc.', start_date=pd.Timestamp(0, tz='UTC'), end_date=pd.Timestamp.max.tz_localize('UTC'), first_traded=None, auto_close_date=None, tick_size=0.01, multiplier=1.0, ), Equity( 1, '1', ExchangeInfo('TSE', 'TSE', 'JP'), currency='CAD', symbol='LMAO', asset_name='Lmao LP', start_date=pd.Timestamp(0, tz='UTC'), end_date=pd.Timestamp.max.tz_localize('UTC'), first_traded=None, auto_close_date=None, tick_size=0.01, multiplier=1.0, ) ] assert_equal(equities, expected_equities) exchange_info = reader.exchange_info expected_exchange_info = { 'NYSE': ExchangeInfo('NYSE', 'NYSE', 'US'), 'TSE': ExchangeInfo('TSE', 'TSE', 'JP'), } assert_equal(exchange_info, expected_exchange_info)
class AssetTestCase(TestCase): # Dynamically list the Asset properties we want to test. asset_attrs = [ name for name, value in vars(Asset).items() if isinstance(value, GetSetDescriptorType) ] # Very wow asset = Asset( 1337, real_sid='1337', exchange_info=ExchangeInfo('THE MOON', 'MOON', '??'), currency='USD', symbol="DOGE", asset_name="DOGECOIN", start_date=pd.Timestamp('2013-12-08 9:31', tz='UTC'), end_date=pd.Timestamp('2014-06-25 11:21', tz='UTC'), first_traded=pd.Timestamp('2013-12-08 9:31', tz='UTC'), auto_close_date=pd.Timestamp('2014-06-26 11:21', tz='UTC'), ) test_exchange = ExchangeInfo('test full', 'test', '??') asset3 = Asset(3, real_sid='3', exchange_info=test_exchange, currency='USD') asset4 = Asset(4, real_sid='4', exchange_info=test_exchange, currency='USD') asset5 = Asset(5, real_sid='5', exchange_info=ExchangeInfo('still testing', 'still testing', '??'), currency='USD') def test_asset_object(self): the_asset = Asset(5061, real_sid='5061', exchange_info=ExchangeInfo('bar', 'bar', '??'), currency='USD') self.assertEqual({5061: 'foo'}[the_asset], 'foo') self.assertEqual(the_asset, 5061) self.assertEqual(5061, the_asset) self.assertEqual(the_asset, the_asset) self.assertEqual(int(the_asset), 5061) self.assertEqual(str(the_asset), 'Asset(5061)') def test_to_and_from_dict(self): asset_from_dict = Asset.from_dict(self.asset.to_dict()) for attr in self.asset_attrs: self.assertEqual( getattr(self.asset, attr), getattr(asset_from_dict, attr), ) def test_asset_is_pickleable(self): asset_unpickled = pickle.loads(pickle.dumps(self.asset)) for attr in self.asset_attrs: self.assertEqual( getattr(self.asset, attr), getattr(asset_unpickled, attr), ) def test_asset_comparisons(self): s_23 = Asset(23, real_sid='23', exchange_info=self.test_exchange, currency='USD') s_24 = Asset(24, real_sid='24', exchange_info=self.test_exchange, currency='USD') self.assertEqual(s_23, s_23) self.assertEqual(s_23, 23) self.assertEqual(23, s_23) self.assertEqual(int32(23), s_23) self.assertEqual(int64(23), s_23) self.assertEqual(s_23, int32(23)) self.assertEqual(s_23, int64(23)) # Check all int types: for int_type in integer_types: self.assertEqual(int_type(23), s_23) self.assertEqual(s_23, int_type(23)) self.assertNotEqual(s_23, s_24) self.assertNotEqual(s_23, 24) self.assertNotEqual(s_23, "23") self.assertNotEqual(s_23, 23.5) self.assertNotEqual(s_23, []) self.assertNotEqual(s_23, None) # Compare to a value that doesn't fit into a platform int: self.assertNotEqual(s_23, sys.maxsize + 1) self.assertLess(s_23, s_24) self.assertLess(s_23, 24) self.assertGreater(24, s_23) self.assertGreater(s_24, s_23) def test_lt(self): self.assertTrue(self.asset3 < self.asset4) self.assertFalse(self.asset4 < self.asset4) self.assertFalse(self.asset5 < self.asset4) def test_le(self): self.assertTrue(self.asset3 <= self.asset4) self.assertTrue(self.asset4 <= self.asset4) self.assertFalse(self.asset5 <= self.asset4) def test_eq(self): self.assertFalse(self.asset3 == self.asset4) self.assertTrue(self.asset4 == self.asset4) self.assertFalse(self.asset5 == self.asset4) def test_ge(self): self.assertFalse(self.asset3 >= self.asset4) self.assertTrue(self.asset4 >= self.asset4) self.assertTrue(self.asset5 >= self.asset4) def test_gt(self): self.assertFalse(self.asset3 > self.asset4) self.assertFalse(self.asset4 > self.asset4) self.assertTrue(self.asset5 > self.asset4) def test_type_mismatch(self): if sys.version_info.major < 3: self.assertIsNotNone(self.asset3 < 'a') self.assertIsNotNone('a' < self.asset3) else: with self.assertRaises(TypeError): self.asset3 < 'a' with self.assertRaises(TypeError): 'a' < self.asset3
def test_repr(self): e = ExchangeInfo('FULL NAME', 'E', 'US') assert_equal(repr(e), "ExchangeInfo('FULL NAME', 'E', 'US')")