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_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_map_identifier_index_to_sids(self):
# Build an empty finder and some Assets
dt = pd.Timestamp('2014-01-01', tz='UTC')
finder = AssetFinder(self.env.engine)
asset1 = Equity(1, symbol="AAPL")
asset2 = Equity(2, symbol="GOOG")
asset200 = Future(200, symbol="CLK15")
asset201 = Future(201, symbol="CLM15")
# Check for correct mapping and types
pre_map = [asset1, asset2, asset200, asset201]
post_map = finder.map_identifier_index_to_sids(pre_map, dt)
self.assertListEqual([1, 2, 200, 201], post_map)
for sid in post_map:
self.assertIsInstance(sid, int)
# Change order and check mapping again
pre_map = [asset201, asset2, asset200, asset1]
post_map = finder.map_identifier_index_to_sids(pre_map, dt)
self.assertListEqual([201, 2, 200, 1], post_map)
def __iter__(self):
asset_cache = {}
for dt, series in self.df.iterrows():
if dt < self.start_date:
continue
if dt > self.end_date:
return
event = FetcherEvent()
# when dt column is converted to be the dataframe's index
# the dt column is dropped. So, we need to manually copy
# dt into the event.
event.dt = dt
for k, v in series.iteritems():
# convert numpy integer types to
# int. This assumes we are on a 64bit
# platform that will not lose information
# by casting.
# TODO: this is only necessary on the
# amazon qexec instances. would be good
# to figure out how to use the numpy dtypes
# without this check and casting.
if isinstance(v, numpy.integer):
v = int(v)
setattr(event, k, v)
# If it has start_date, then it's already an Asset
# object from asset_for_symbol, and we don't have to
# transform it any further. Checking for start_date is
# faster than isinstance.
if event.sid in asset_cache:
event.sid = asset_cache[event.sid]
elif hasattr(event.sid, 'start_date'):
# Clone for user algo code, if we haven't already.
asset_cache[event.sid] = event.sid
elif self.finder and isinstance(event.sid, int):
asset = self.finder.retrieve_asset(event.sid,
default_none=True)
if asset:
# Clone for user algo code.
event.sid = asset_cache[asset] = asset
elif self.mask:
# When masking drop all non-mappable values.
continue
elif self.symbol is None:
# If the event's sid property is an int we coerce
# it into an Equity.
event.sid = asset_cache[event.sid] = Equity(event.sid)
event.type = DATASOURCE_TYPE.CUSTOM
event.source_id = self.namestring
yield event
def test_transaction_repr(self):
dt = pd.Timestamp('2017-01-01')
asset = Equity(1, exchange='test')
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_transaction_repr(self):
dt = pd.Timestamp('2017-01-01')
asset = Equity(
1,
real_sid='1',
currency='USD',
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_security_dates_warning(self):
# Build an asset with an end_date
eq_end = pd.Timestamp('2012-01-01', tz='UTC')
equity_asset = Equity(1, symbol="TESTEQ", end_date=eq_end)
# Catch all warnings
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered
warnings.simplefilter("always")
equity_asset.security_start_date
equity_asset.security_end_date
equity_asset.security_name
# Verify the warning
self.assertEqual(3, len(w))
for warning in w:
self.assertTrue(
issubclass(warning.category, DeprecationWarning))
def test_consume_asset_as_identifier(self):
# Build some end dates
eq_end = pd.Timestamp('2012-01-01', tz='UTC')
fut_end = pd.Timestamp('2008-01-01', tz='UTC')
# Build some simple Assets
equity_asset = Equity(1, symbol="TESTEQ", end_date=eq_end)
future_asset = Future(200, symbol="TESTFUT", end_date=fut_end)
# Consume the Assets
finder = AssetFinder()
finder.consume_identifiers([equity_asset, future_asset])
# Test equality with newly built Assets
self.assertEqual(equity_asset, finder.retrieve_asset(1))
self.assertEqual(future_asset, finder.retrieve_asset(200))
self.assertEqual(eq_end, finder.retrieve_asset(1).end_date)
self.assertEqual(fut_end, finder.retrieve_asset(200).end_date)
def _retrieve_equity(self, sid):
"""
Retrieve the Equity object of a given sid.
"""
try:
return self._equity_cache[sid]
except KeyError:
pass
data = self.select_equity_by_sid(sid).execute().fetchone()
# Convert 'data' from a RowProxy object to a dict, to allow assignment
data = dict(data.items())
if data:
_convert_asset_str_fields(data)
_convert_asset_timestamp_fields(data)
equity = Equity(**data)
else:
equity = None
self._equity_cache[sid] = equity
return equity
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 _convert_row_to_equity(self, row):
"""
Converts a SQLAlchemy equity row to an Equity object.
"""
return Equity(**_convert_asset_timestamp_fields(dict(row)))
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)
