saymrwulf/zipline
1
0
Fork 0
mirror of https://github.com/saymrwulf/zipline.git synced 2026-05-16 21:10:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
zipline/tests/test_benchmark.py

414 lines
14 KiB
Python
Raw Normal View History

ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
#
# Copyright 2015 Quantopian, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
import logbook
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
import numpy as np
import pandas as pd
ENH: Add get_range to BenchmarkSource
2017-05-25 14:14:40 +00:00
from pandas.util.testing import assert_series_equal
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
from zipline.data.data_portal import DataPortal
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
from zipline.errors import (
BenchmarkAssetNotAvailableTooEarly,
BenchmarkAssetNotAvailableTooLate,
InvalidBenchmarkAsset)
from zipline.sources.benchmark_source import BenchmarkSource
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
from zipline.utils.run_algo import BenchmarkSpec
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
from zipline.testing import (
MockDailyBarReader,
create_minute_bar_data,
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
parameter_space,
tmp_bcolz_equity_minute_bar_reader,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
)
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
from zipline.testing.predicates import assert_equal
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
from zipline.testing.fixtures import (
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
WithAssetFinder,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
WithDataPortal,
WithSimParams,
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
WithTmpDir,
TST: Make room for multiple calendars in tests. When adding fixtures for futures data, there will be a need for multiple calendars in the fixture ecosystem. e.g. a test that includes both equities and futures would need an overall calendar which encompasses both equities and futures; however, the test data for equities should still still be limited to the bounds set by the NYSE calendar. Make the fixtures that setup trading calendars and values dervied from the trading calendar (e.g. trading sessions) accept an iterable of calendars which need to be created, then populate those values into a dict keyed by the calendar name. Change `WithNYSETradingDays` to include sessions in the name, since we are moving to session as the name for the 'day' unit. Provide `trading_days` which is really "NYSE trading sessions` on `WithTradingSessions` for backwards compatibility.
2016-08-02 17:19:45 +00:00
WithTradingCalendars,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
ZiplineTestCase,
)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
from zipline.testing.core import make_test_handler
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
TST: Make room for multiple calendars in tests. When adding fixtures for futures data, there will be a need for multiple calendars in the fixture ecosystem. e.g. a test that includes both equities and futures would need an overall calendar which encompasses both equities and futures; however, the test data for equities should still still be limited to the bounds set by the NYSE calendar. Make the fixtures that setup trading calendars and values dervied from the trading calendar (e.g. trading sessions) accept an iterable of calendars which need to be created, then populate those values into a dict keyed by the calendar name. Change `WithNYSETradingDays` to include sessions in the name, since we are moving to session as the name for the 'day' unit. Provide `trading_days` which is really "NYSE trading sessions` on `WithTradingSessions` for backwards compatibility.
2016-08-02 17:19:45 +00:00
class TestBenchmark(WithDataPortal, WithSimParams, WithTradingCalendars,
TST: Refactors more tests to use WithTradingSchedule
2016-05-06 18:24:12 +00:00
ZiplineTestCase):
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
START_DATE = pd.Timestamp('2006-01-03', tz='utc')
END_DATE = pd.Timestamp('2006-12-29', tz='utc')
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
@classmethod
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
def make_equity_info(cls):
return pd.DataFrame.from_dict(
{
1: {
Revert "Merge pull request #1354 from quantopian/revert-1302-point-in-time-asset-db" This reverts commit 3b633011c6f9a82703e274680cafcf3c28cdcfd7, reversing changes made to 70ac5323def0df58360c3f2c67112778728c83db.
2016-07-29 15:46:39 +00:00
'symbol': 'A',
'start_date': cls.START_DATE,
ENH: made `exchange` a required parameter to `Asset` and its subclasses This required updating a lot of tests.
2016-08-03 02:52:47 +00:00
'end_date': cls.END_DATE + pd.Timedelta(days=1),
"exchange": "TEST",
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
},
2: {
Revert "Merge pull request #1354 from quantopian/revert-1302-point-in-time-asset-db" This reverts commit 3b633011c6f9a82703e274680cafcf3c28cdcfd7, reversing changes made to 70ac5323def0df58360c3f2c67112778728c83db.
2016-07-29 15:46:39 +00:00
'symbol': 'B',
'start_date': cls.START_DATE,
ENH: made `exchange` a required parameter to `Asset` and its subclasses This required updating a lot of tests.
2016-08-03 02:52:47 +00:00
'end_date': cls.END_DATE + pd.Timedelta(days=1),
"exchange": "TEST",
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
},
3: {
Revert "Merge pull request #1354 from quantopian/revert-1302-point-in-time-asset-db" This reverts commit 3b633011c6f9a82703e274680cafcf3c28cdcfd7, reversing changes made to 70ac5323def0df58360c3f2c67112778728c83db.
2016-07-29 15:46:39 +00:00
'symbol': 'C',
'start_date': pd.Timestamp('2006-05-26', tz='utc'),
ENH: made `exchange` a required parameter to `Asset` and its subclasses This required updating a lot of tests.
2016-08-03 02:52:47 +00:00
'end_date': pd.Timestamp('2006-08-09', tz='utc'),
"exchange": "TEST",
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
},
4: {
Revert "Merge pull request #1354 from quantopian/revert-1302-point-in-time-asset-db" This reverts commit 3b633011c6f9a82703e274680cafcf3c28cdcfd7, reversing changes made to 70ac5323def0df58360c3f2c67112778728c83db.
2016-07-29 15:46:39 +00:00
'symbol': 'D',
'start_date': cls.START_DATE,
ENH: made `exchange` a required parameter to `Asset` and its subclasses This required updating a lot of tests.
2016-08-03 02:52:47 +00:00
'end_date': cls.END_DATE + pd.Timedelta(days=1),
"exchange": "TEST",
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
},
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
},
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
orient='index',
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
@classmethod
MAINT: Add equity to naming of bar data classes. In preparation of adding futures, add equity to the names of both the classes and methods for writing bcolz data. Futures data will use a different minutes per day with a separate reader. This change will allow both equity and futures fixtures to be side by side. Also, break out the method which generates the dataframes and trading days member into fixtures (`EquityMinuteBarData` and `EquityDailyBarData`) on which the `*BarReader` fixture depends. This fixture is separated out to enable reader/writers in different formats to use the same data setup. (There is internal code which needs to write minute and daily bar data in a database format.)
2016-06-28 19:30:20 +00:00
def make_adjustment_writer_equity_daily_bar_reader(cls):
ENH: vectorize dividend ratio calculation
2018-09-21 21:31:37 +00:00
return MockDailyBarReader(
dates=cls.trading_calendar.sessions_in_range(
cls.START_DATE,
cls.END_DATE,
),
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
@classmethod
def make_stock_dividends_data(cls):
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
declared_date = cls.sim_params.sessions[45]
ex_date = cls.sim_params.sessions[50]
record_date = pay_date = cls.sim_params.sessions[55]
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
return pd.DataFrame({
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
'sid': np.array([4], dtype=np.uint32),
'payment_sid': np.array([5], dtype=np.uint32),
'ratio': np.array([2], dtype=np.float64),
'declared_date': np.array([declared_date], dtype='datetime64[ns]'),
'ex_date': np.array([ex_date], dtype='datetime64[ns]'),
'record_date': np.array([record_date], dtype='datetime64[ns]'),
'pay_date': np.array([pay_date], dtype='datetime64[ns]'),
})
def test_normal(self):
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
days_to_use = self.sim_params.sessions[1:]
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
source = BenchmarkSource(
MAINT: Remove TradingEnvironment.
2018-05-21 05:55:15 +00:00
self.asset_finder.retrieve_asset(1),
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
self.trading_calendar,
days_to_use,
self.data_portal
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
)
# should be the equivalent of getting the price history, then doing
# a pct_change on it
manually_calculated = self.data_portal.get_history_window(
MAINT: Pass data_frequency to get_history_window This allows us to remove the check for whether the provided dt had a time of midnight, which was a flimsy way to infer if the data frequency was 'daily'. Besides the explicit check being preferable, this method was broken on the futures calendar, since midnight is a valid market minute.
2017-05-04 20:06:15 +00:00
[1],
days_to_use[-1],
len(days_to_use),
"1d",
"close",
"daily",
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
)[1].pct_change()
# compare all the fields except the first one, for which we don't have
# data in manually_calculated
for idx, day in enumerate(days_to_use[1:]):
self.assertEqual(
source.get_value(day),
manually_calculated[idx + 1]
)
ENH: Add get_range to BenchmarkSource
2017-05-25 14:14:40 +00:00
# compare a slice of the data
assert_series_equal(
source.get_range(days_to_use[1], days_to_use[10]),
manually_calculated[1:11]
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
def test_asset_not_trading(self):
MAINT: Remove TradingEnvironment.
2018-05-21 05:55:15 +00:00
benchmark = self.asset_finder.retrieve_asset(3)
FIX: Error message for BenchmarkAssetNotAvailableTooLate is wrong Should be '...does not exist on self.trading_days[-1]...' not self.trading_days[0]
2016-04-27 17:31:28 +00:00
benchmark_start = benchmark.start_date
benchmark_end = benchmark.end_date
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
with self.assertRaises(BenchmarkAssetNotAvailableTooEarly) as exc:
BenchmarkSource(
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
benchmark,
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
self.trading_calendar,
self.sim_params.sessions[1:],
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
self.data_portal
)
self.assertEqual(
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
'Equity(3 [C]) does not exist on %s. It started trading on %s.' %
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
(self.sim_params.sessions[1], benchmark_start),
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
exc.exception.message
)
with self.assertRaises(BenchmarkAssetNotAvailableTooLate) as exc2:
BenchmarkSource(
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
benchmark,
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
self.trading_calendar,
self.sim_params.sessions[120:],
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
self.data_portal
)
self.assertEqual(
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
'Equity(3 [C]) does not exist on %s. It stopped trading on %s.' %
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
(self.sim_params.sessions[-1], benchmark_end),
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
exc2.exception.message
)
def test_asset_IPOed_same_day(self):
# gotta get some minute data up in here.
# add sid 4 for a couple of days
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
minutes = self.trading_calendar.minutes_for_sessions_in_range(
self.sim_params.sessions[0],
self.sim_params.sessions[5]
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
)
MAINT: Add equity to naming of bar data classes. In preparation of adding futures, add equity to the names of both the classes and methods for writing bcolz data. Futures data will use a different minutes per day with a separate reader. This change will allow both equity and futures fixtures to be side by side. Also, break out the method which generates the dataframes and trading days member into fixtures (`EquityMinuteBarData` and `EquityDailyBarData`) on which the `*BarReader` fixture depends. This fixture is separated out to enable reader/writers in different formats to use the same data setup. (There is internal code which needs to write minute and daily bar data in a database format.)
2016-06-28 19:30:20 +00:00
tmp_reader = tmp_bcolz_equity_minute_bar_reader(
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
self.trading_calendar,
self.trading_calendar.all_sessions,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
create_minute_bar_data(minutes, [2]),
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
)
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
with tmp_reader as reader:
data_portal = DataPortal(
MAINT: Remove TradingEnvironment.
2018-05-21 05:55:15 +00:00
self.asset_finder, self.trading_calendar,
MAINT: Adds first_trading_day arg to DataPortal Instead of inferring it from the minute/daily writer, we now require the first trading day to be passed explicitly, so the creator of the DataPortal controls what is used as the first trading day.
2016-06-01 20:52:39 +00:00
first_trading_day=reader.first_trading_day,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
equity_minute_reader=reader,
MAINT: Add equity to naming of bar data classes. In preparation of adding futures, add equity to the names of both the classes and methods for writing bcolz data. Futures data will use a different minutes per day with a separate reader. This change will allow both equity and futures fixtures to be side by side. Also, break out the method which generates the dataframes and trading days member into fixtures (`EquityMinuteBarData` and `EquityDailyBarData`) on which the `*BarReader` fixture depends. This fixture is separated out to enable reader/writers in different formats to use the same data setup. (There is internal code which needs to write minute and daily bar data in a database format.)
2016-06-28 19:30:20 +00:00
equity_daily_reader=self.bcolz_equity_daily_bar_reader,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
adjustment_reader=self.adjustment_reader,
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
source = BenchmarkSource(
MAINT: Remove TradingEnvironment.
2018-05-21 05:55:15 +00:00
self.asset_finder.retrieve_asset(2),
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
self.trading_calendar,
self.sim_params.sessions,
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
data_portal
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
Re-implemented the Calendar API. Instead of having separate ExchangeCalendar and TradingSchedule objects, we now just have TradingCalendar. The TradingCalendar keeps track of each session (defined as a contiguous set of minutes between an open and a close). It's also responsible for handling the grouping logic of any given minute to its containing session, or the next/previous session if it's not a market minute for the given calendar.
2016-06-20 14:30:31 +00:00
days_to_use = self.sim_params.sessions
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
# first value should be 0.0, coming from daily data
self.assertAlmostEquals(0.0, source.get_value(days_to_use[0]))
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
manually_calculated = data_portal.get_history_window(
[2], days_to_use[-1],
len(days_to_use),
"1d",
"close",
MAINT: Pass data_frequency to get_history_window This allows us to remove the check for whether the provided dt had a time of midnight, which was a flimsy way to infer if the data frequency was 'daily'. Besides the explicit check being preferable, this method was broken on the futures calendar, since midnight is a valid market minute.
2017-05-04 20:06:15 +00:00
"daily",
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
)[2].pct_change()
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
MAINT: make the data loading apis more consistent. Changes BcolzDailyBarWriter to not be an abc, data is passed as an iterator of (sid, dataframe) pairs to the write method. Changes the AssetsDBWriter to be a single class which accepts an engine at construction time and has a `write` method for writing dataframes for the various tables. We no longer support writing the various other data types, callers should coerce their data into a dataframe themselves. See zipline.assets.synthetic for some helpers to do this. Adds many new fixtures and updates some existing fixtures to use the new ones: WithDefaultDateBounds A fixture that provides the suite a START_DATE and END_DATE. This is meant to make it easy for other fixtures to synchronize their date ranges without depending on eachother in strange ways. For example, WithBcolzMinuteBarReader and WithBcolzDailyBarReader by default should both have data for the same dates, so they may use depend on WithDefaultDates without forcing a dependency between them. WithTmpDir, WithInstanceTmpDir Provides the suite or individual test case a temporary directory. WithBcolzDailyBarReader Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzDailyBarWriter.write WithBcolzDailyBarReaderFromCSVs Provides the suite a BcolzDailyBarReader which reads from bcolz data written to a temporary directory. The data will be read from a collection of CSV files and then converted into the bcolz data through BcolzDailyBarWriter.write_csvs WithBcolzMinuteBarReader Provides the suite a BcolzMinuteBarReader which reads from bcolz data written to a temporary directory. The data will be read from dataframes and then converted to bcolz files with BcolzMinuteBarWriter.write WithAdjustmentReader Provides the suite a SQLiteAdjustmentReader which reads from an in memory sqlite database. The data will be read from dataframes and then converted into sqlite with SQLiteAdjustmentWriter.write WithDataPortal Provides each test case a DataPortal object with data from temporary resources.
2016-03-31 19:26:57 +00:00
for idx, day in enumerate(days_to_use[1:]):
self.assertEqual(
source.get_value(day),
manually_calculated[idx + 1]
)
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
def test_no_stock_dividends_allowed(self):
# try to use sid(4) as benchmark, should blow up due to the presence
# of a stock dividend
with self.assertRaises(InvalidBenchmarkAsset) as exc:
BenchmarkSource(
MAINT: Remove TradingEnvironment.
2018-05-21 05:55:15 +00:00
self.asset_finder.retrieve_asset(4),
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
self.trading_calendar,
self.sim_params.sessions,
self.data_portal
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
)
MAINT: Remove environment as an argument to benchmark source. (#1816) MAINT: Remove environment as an argument to benchmark source. To allow the BenchmarkSource class to be more easily used in contexts other than a TradingAlgorithm, remove the TradingEnvironment as an argument to the benchmark source. Instead: - Pass a benchmark Asset, instead of a bencmark sid; so that the asset_finder does not need to be passed to the benchmark source. - Pass the pre-calculated benchmark_returns instead of an env, which contains the benchmark_returns; a consumer can let the benchmark_returns stay as the default of `None` when using an asset. We may want to further refactor and make two different classes, instead of relying on a combination of existence/non-existence of benchmark_asset and benchmark_returns. That refactoring should be easier to do with this change.
2017-05-25 20:11:25 +00:00
self.assertEqual("Equity(4 [D]) cannot be used as the benchmark "
"because it has a stock dividend on 2006-03-16 "
"00:00:00. Choose another asset to use as the "
"benchmark.",
ENH: Rewrite of Zipline to use lazy access pattern More documentation to follow in release notes. Based on lazy-mainline branch, see for more details. Also-By: Jean Bredeche <jean@quantopian.com> Also-By: Andrew Liang <aliang@quantopian.com> Also-By: Abhijeet Kalyan <akalyan@quantopian.com>
2016-04-04 16:34:26 +00:00
exc.exception.message)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
class BenchmarkSpecTestCase(WithTmpDir,
WithAssetFinder,
ZiplineTestCase):
@classmethod
def init_class_fixtures(cls):
super(BenchmarkSpecTestCase, cls).init_class_fixtures()
zero_returns_index = pd.date_range(
cls.START_DATE,
cls.END_DATE,
freq='D',
tz='utc',
)
cls.zero_returns = pd.Series(index=zero_returns_index, data=0.0)
def init_instance_fixtures(self):
super(BenchmarkSpecTestCase, self).init_instance_fixtures()
self.log_handler = self.enter_instance_context(make_test_handler(self))
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
@classmethod
def make_equity_info(cls):
return pd.DataFrame.from_dict(
{
1: {
'symbol': 'A',
'start_date': cls.START_DATE,
'end_date': cls.END_DATE + pd.Timedelta(days=1),
"exchange": "TEST",
},
2: {
'symbol': 'B',
'start_date': cls.START_DATE,
'end_date': cls.END_DATE + pd.Timedelta(days=1),
"exchange": "TEST",
}
},
orient='index',
)
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
def logs_at_level(self, level):
return [
r.message for r in self.log_handler.records if r.level == level
]
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
def resolve_spec(self, spec):
return spec.resolve(self.asset_finder, self.START_DATE, self.END_DATE)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
def test_no_benchmark(self):
"""Test running with no benchmark provided.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
We should have no benchmark sid and have a returns series of all zeros.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
"""
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
spec = BenchmarkSpec.from_cli_params(
no_benchmark=False,
benchmark_sid=None,
benchmark_symbol=None,
benchmark_file=None,
)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
sid, returns = self.resolve_spec(spec)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
self.assertIs(sid, None)
self.assertIs(returns, None)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
warnings = self.logs_at_level(logbook.WARNING)
expected = [
'No benchmark configured. Assuming algorithm calls set_benchmark.',
'Pass --benchmark-sid, --benchmark-symbol, or --benchmark-file to set a source of benchmark returns.', # noqa
"Pass --no-benchmark to use a dummy benchmark of zero returns.",
]
assert_equal(warnings, expected)
def test_no_benchmark_explicitly_disabled(self):
"""Test running with no benchmark provided, with no_benchmark flag.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
"""
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
spec = BenchmarkSpec.from_cli_params(
no_benchmark=True,
benchmark_sid=None,
benchmark_symbol=None,
benchmark_file=None,
)
sid, returns = self.resolve_spec(spec)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
self.assertIs(sid, None)
assert_series_equal(returns, self.zero_returns)
warnings = self.logs_at_level(logbook.WARNING)
expected = []
assert_equal(warnings, expected)
@parameter_space(case=[('A', 1), ('B', 2)])
def test_benchmark_symbol(self, case):
"""Test running with no benchmark provided, with no_benchmark flag.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
"""
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
symbol, expected_sid = case
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
spec = BenchmarkSpec.from_cli_params(
no_benchmark=False,
benchmark_sid=None,
benchmark_symbol=symbol,
benchmark_file=None,
)
sid, returns = self.resolve_spec(spec)
assert_equal(sid, expected_sid)
self.assertIs(returns, None)
warnings = self.logs_at_level(logbook.WARNING)
expected = []
assert_equal(warnings, expected)
@parameter_space(input_sid=[1, 2])
def test_benchmark_sid(self, input_sid):
"""Test running with no benchmark provided, with no_benchmark flag.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
"""
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
spec = BenchmarkSpec.from_cli_params(
no_benchmark=False,
benchmark_sid=input_sid,
benchmark_symbol=None,
benchmark_file=None,
)
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
sid, returns = self.resolve_spec(spec)
assert_equal(sid, input_sid)
self.assertIs(returns, None)
warnings = self.logs_at_level(logbook.WARNING)
expected = []
assert_equal(warnings, expected)
def test_benchmark_file(self):
"""Test running with a benchmark file.
TEST Adding tests for the new benchmark parameters. I used mock functions as I couldn't find in the test fixtures a way to call run_algo.
2020-04-05 21:30:49 +00:00
"""
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
csv_file_path = self.tmpdir.getpath('b.csv')
with open(csv_file_path, 'w') as csv_file:
csv_file.write("date,return\n"
"2020-01-03 00:00:00+00:00,-0.1\n"
"2020-01-06 00:00:00+00:00,0.333\n"
"2020-01-07 00:00:00+00:00,0.167\n"
"2020-01-08 00:00:00+00:00,0.143\n"
"2020-01-09 00:00:00+00:00,6.375\n")
spec = BenchmarkSpec.from_cli_params(
no_benchmark=False,
benchmark_sid=None,
benchmark_symbol=None,
benchmark_file=csv_file_path,
)
sid, returns = self.resolve_spec(spec)
self.assertIs(sid, None)
expected_dates = pd.to_datetime(
STY: Flake8 style amendments
2020-04-20 13:16:28 +00:00
['2020-01-03', '2020-01-06', '2020-01-07',
'2020-01-08', '2020-01-09'],
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
utc=True,
)
expected_values = [-0.1, 0.333, 0.167, 0.143, 6.375]
STY: Flake8 style amendments
2020-04-20 13:16:28 +00:00
expected_returns = pd.Series(index=expected_dates,
data=expected_values)
ENH: Rework benchmark handling for zipline CLI. Reworks how we choose a benchmark source for the zipline CLI and zipline.utils.run_algo.run_algorithm. The logic for choosing a benchmark is now consolidated in a new `BenchmarkSpec` class. Benchmarks can be configured from several possible options: - An in-memory series can be passed as `benchmark_returns`. This is mostly useful for testing, or for use with `run_algorithm`. - A path or file-like object can be passed as `benchmark_file`. - A sid can be passed as `benchmark_sid` - A symbol can be passed as `benchmark_symbol`. - `no_benchmark` can be passed to use a dummy benchmark of all zero returns. `BenchmarkSpec` takes all the parameters listed above, and "resolves" them into either a sid or a series of benchmark returns, which are forwarded to TradingAlgorithm, which already takes `benchmark_returns` or `benchmark_sid`. If none of the above parameters are passed, we log a warning, emit None for both values, and assume that the algorithm will call `set_benchmark` in its `initialize` method.
2020-04-16 17:57:11 +00:00
assert_series_equal(returns, expected_returns, check_names=False)
warnings = self.logs_at_level(logbook.WARNING)
expected = []
assert_equal(warnings, expected)
Reference in a new issue Copy permalink