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')")
