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)