Python TradingEnvironment.write_data方法代码示例

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
class TestChangeOfSids(TestCase):
    def setUp(self):
        self.sids = range(90)
        self.env = TradingEnvironment()
        self.env.write_data(equities_identifiers=self.sids)

        self.sim_params = factory.create_simulation_parameters(
            start=datetime(1990, 1, 1, tzinfo=pytz.utc),
            end=datetime(1990, 1, 8, tzinfo=pytz.utc),
            env=self.env,
        )

    def test_all_sids_passed(self):
        algo = BatchTransformAlgorithmSetSid(
            sim_params=self.sim_params,
            env=self.env,
        )
        source = DifferentSidSource()
        algo.run(source)
        for i, (df, date) in enumerate(zip(algo.history, source.trading_days)):
            self.assertEqual(df.index[-1], date, "Newest event doesn't \
                             match.")

            for sid in self.sids[:i]:
                self.assertIn(sid, df.columns)

            self.assertEqual(df.iloc[-1].iloc[-1], i)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def test_yahoo_bars_to_panel_source(self):
        env = TradingEnvironment()
        finder = AssetFinder(env.engine)
        stocks = ['AAPL', 'GE']
        env.write_data(equities_identifiers=stocks)
        start = pd.datetime(1993, 1, 1, 0, 0, 0, 0, pytz.utc)
        end = pd.datetime(2002, 1, 1, 0, 0, 0, 0, pytz.utc)
        data = factory.load_bars_from_yahoo(stocks=stocks,
                                            indexes={},
                                            start=start,
                                            end=end)
        check_fields = ['sid', 'open', 'high', 'low', 'close',
                        'volume', 'price']

        copy_panel = data.copy()
        sids = finder.map_identifier_index_to_sids(
            data.items, data.major_axis[0]
        )
        copy_panel.items = sids
        source = DataPanelSource(copy_panel)
        for event in source:
            for check_field in check_fields:
                self.assertIn(check_field, event)
            self.assertTrue(isinstance(event['volume'], (integer_types)))
            self.assertTrue(event['sid'] in sids)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUpClass(cls):
        metadata = {
            0: {
                'symbol': 'CLG06',
                'root_symbol': 'CL',
                'start_date': pd.Timestamp('2005-12-01', tz='UTC'),
                'notice_date': pd.Timestamp('2005-12-20', tz='UTC'),
                'expiration_date': pd.Timestamp('2006-01-20', tz='UTC')},
            1: {
                'root_symbol': 'CL',
                'symbol': 'CLK06',
                'start_date': pd.Timestamp('2005-12-01', tz='UTC'),
                'notice_date': pd.Timestamp('2006-03-20', tz='UTC'),
                'expiration_date': pd.Timestamp('2006-04-20', tz='UTC')},
            2: {
                'symbol': 'CLQ06',
                'root_symbol': 'CL',
                'start_date': pd.Timestamp('2005-12-01', tz='UTC'),
                'notice_date': pd.Timestamp('2006-06-20', tz='UTC'),
                'expiration_date': pd.Timestamp('2006-07-20', tz='UTC')},
            3: {
                'symbol': 'CLX06',
                'root_symbol': 'CL',
                'start_date': pd.Timestamp('2006-02-01', tz='UTC'),
                'notice_date': pd.Timestamp('2006-09-20', tz='UTC'),
                'expiration_date': pd.Timestamp('2006-10-20', tz='UTC')}
        }

        env = TradingEnvironment(load=noop_load)
        env.write_data(futures_data=metadata)
        cls.asset_finder = env.asset_finder

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUp(self):
        self.constants = {
            # Every day, assume every stock starts at 2, goes down to 1,
            # goes up to 4, and finishes at 3.
            USEquityPricing.low: 1,
            USEquityPricing.open: 2,
            USEquityPricing.close: 3,
            USEquityPricing.high: 4,
        }
        self.asset_ids = [1, 2, 3, 4]
        self.dates = date_range('2014-01', '2014-03', freq='D', tz='UTC')
        self.loader = PrecomputedLoader(
            constants=self.constants,
            dates=self.dates,
            sids=self.asset_ids,
        )

        self.asset_info = make_simple_equity_info(
            self.asset_ids,
            start_date=self.dates[0],
            end_date=self.dates[-1],
        )
        environment = TradingEnvironment()
        environment.write_data(equities_df=self.asset_info)
        self.asset_finder = environment.asset_finder
        self.assets = self.asset_finder.retrieve_all(self.asset_ids)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def test_compute_lifetimes(self):
        num_assets = 4
        env = TradingEnvironment()
        trading_day = env.trading_day
        first_start = pd.Timestamp('2015-04-01', tz='UTC')

        frame = make_rotating_asset_info(
            num_assets=num_assets,
            first_start=first_start,
            frequency=env.trading_day,
            periods_between_starts=3,
            asset_lifetime=5
        )

        env.write_data(equities_df=frame)
        finder = env.asset_finder

        all_dates = pd.date_range(
            start=first_start,
            end=frame.end_date.max(),
            freq=trading_day,
        )

        for dates in all_subindices(all_dates):
            expected_with_start_raw = full(
                shape=(len(dates), num_assets),
                fill_value=False,
                dtype=bool,
            )
            expected_no_start_raw = full(
                shape=(len(dates), num_assets),
                fill_value=False,
                dtype=bool,
            )

            for i, date in enumerate(dates):
                it = frame[['start_date', 'end_date']].itertuples()
                for j, start, end in it:
                    # This way of doing the checks is redundant, but very
                    # clear.
                    if start <= date <= end:
                        expected_with_start_raw[i, j] = True
                        if start < date:
                            expected_no_start_raw[i, j] = True

            expected_with_start = pd.DataFrame(
                data=expected_with_start_raw,
                index=dates,
                columns=frame.index.values,
            )
            result = finder.lifetimes(dates, include_start_date=True)
            assert_frame_equal(result, expected_with_start)

            expected_no_start = pd.DataFrame(
                data=expected_no_start_raw,
                index=dates,
                columns=frame.index.values,
            )
            result = finder.lifetimes(dates, include_start_date=False)
            assert_frame_equal(result, expected_no_start)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUpClass(cls):
        metadata = {
            0: {
                "symbol": "CLG06",
                "root_symbol": "CL",
                "start_date": pd.Timestamp("2005-12-01", tz="UTC"),
                "notice_date": pd.Timestamp("2005-12-20", tz="UTC"),
                "expiration_date": pd.Timestamp("2006-01-20", tz="UTC"),
            },
            1: {
                "root_symbol": "CL",
                "symbol": "CLK06",
                "start_date": pd.Timestamp("2005-12-01", tz="UTC"),
                "notice_date": pd.Timestamp("2006-03-20", tz="UTC"),
                "expiration_date": pd.Timestamp("2006-04-20", tz="UTC"),
            },
            2: {
                "symbol": "CLQ06",
                "root_symbol": "CL",
                "start_date": pd.Timestamp("2005-12-01", tz="UTC"),
                "notice_date": pd.Timestamp("2006-06-20", tz="UTC"),
                "expiration_date": pd.Timestamp("2006-07-20", tz="UTC"),
            },
            3: {
                "symbol": "CLX06",
                "root_symbol": "CL",
                "start_date": pd.Timestamp("2006-02-01", tz="UTC"),
                "notice_date": pd.Timestamp("2006-09-20", tz="UTC"),
                "expiration_date": pd.Timestamp("2006-10-20", tz="UTC"),
            },
        }

        env = TradingEnvironment(load=noop_load)
        env.write_data(futures_data=metadata)
        cls.asset_finder = env.asset_finder

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUp(self):
        self.assets = [1, 2, 3]
        self.dates = date_range("2014-01", "2014-03", freq="D", tz="UTC")

        asset_info = make_simple_asset_info(self.assets, start_date=self.dates[0], end_date=self.dates[-1])
        env = TradingEnvironment()
        env.write_data(equities_df=asset_info)
        self.asset_finder = env.asset_finder

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
 def test_sids(self):
     # Ensure that the sids property of the AssetFinder is functioning
     env = TradingEnvironment()
     env.write_data(equities_identifiers=[1, 2, 3])
     sids = env.asset_finder.sids
     self.assertEqual(3, len(sids))
     self.assertTrue(1 in sids)
     self.assertTrue(2 in sids)
     self.assertTrue(3 in sids)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUp(self):
        self.assets = [1, 2, 3]
        self.dates = date_range('2014-01-01', '2014-02-01', freq='D', tz='UTC')

        asset_info = make_simple_asset_info(
            self.assets,
            start_date=self.dates[0],
            end_date=self.dates[-1],
        )
        env = TradingEnvironment()
        env.write_data(equities_df=asset_info)
        self.asset_finder = env.asset_finder

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUp(self):
        self.__calendar = date_range('2014', '2015', freq=trading_day)
        self.__assets = assets = Int64Index(arange(1, 20))

        # Set up env for test
        env = TradingEnvironment()
        env.write_data(
            equities_df=make_simple_asset_info(
                assets,
                self.__calendar[0],
                self.__calendar[-1],
            ))
        self.__finder = env.asset_finder
        self.__mask = self.__finder.lifetimes(self.__calendar[-10:])

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def test_compute_lifetimes(self):
        num_assets = 4
        env = TradingEnvironment()
        trading_day = env.trading_day
        first_start = pd.Timestamp('2015-04-01', tz='UTC')

        frame = make_rotating_asset_info(
            num_assets=num_assets,
            first_start=first_start,
            frequency=env.trading_day,
            periods_between_starts=3,
            asset_lifetime=5
        )

        env.write_data(equities_df=frame)
        finder = env.asset_finder

        all_dates = pd.date_range(
            start=first_start,
            end=frame.end_date.max(),
            freq=trading_day,
        )

        for dates in all_subindices(all_dates):
            expected_mask = full(
                shape=(len(dates), num_assets),
                fill_value=False,
                dtype=bool,
            )

            for i, date in enumerate(dates):
                it = frame[['start_date', 'end_date']].itertuples()
                for j, start, end in it:
                    if start <= date <= end:
                        expected_mask[i, j] = True

            # Filter out columns with all-empty columns.
            expected_result = pd.DataFrame(
                data=expected_mask,
                index=dates,
                columns=frame.index.values,
            )

            actual_result = finder.lifetimes(dates)
            assert_frame_equal(actual_result, expected_result)

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def setUp(self):
        self.__calendar = date_range('2014', '2015', freq=trading_day)
        self.__assets = assets = Int64Index(arange(1, 20))

        # Set up env for test
        env = TradingEnvironment()
        env.write_data(
            equities_df=make_simple_asset_info(
                assets,
                self.__calendar[0],
                self.__calendar[-1],
            ),
        )
        self.__finder = env.asset_finder

        # Use a 30-day period at the end of the year by default.
        self.__mask = self.__finder.lifetimes(
            self.__calendar[-30:],
            include_start_date=False,
        )

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
    def test_algo_without_rl_violation_after_delete(self):
        new_tempdir = TempDirectory()
        try:
            with security_list_copy():
                # add a delete statement removing bzq
                # write a new delete statement file to disk
                add_security_data([], ['BZQ'])

                # now fast-forward to self.extra_knowledge_date.  requires
                # a new env, simparams, and dataportal
                env = TradingEnvironment()
                sim_params = factory.create_simulation_parameters(
                    start=self.extra_knowledge_date, num_days=4, env=env)

                env.write_data(equities_data={
                    "0": {
                        'symbol': 'BZQ',
                        'start_date': sim_params.period_start,
                        'end_date': sim_params.period_end,
                    }
                })

                data_portal = create_data_portal(
                    env,
                    new_tempdir,
                    sim_params,
                    range(0, 5)
                )

                algo = RestrictedAlgoWithoutCheck(
                    symbol='BZQ', sim_params=sim_params, env=env
                )
                algo.run(data_portal)

        finally:
            new_tempdir.cleanup()

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
def build_lookup_generic_cases():
    """
    Generate test cases for AssetFinder test_lookup_generic.
    """

    unique_start = pd.Timestamp("2013-01-01", tz="UTC")
    unique_end = pd.Timestamp("2014-01-01", tz="UTC")

    dupe_0_start = pd.Timestamp("2013-01-01", tz="UTC")
    dupe_0_end = dupe_0_start + timedelta(days=1)

    dupe_1_start = pd.Timestamp("2013-01-03", tz="UTC")
    dupe_1_end = dupe_1_start + timedelta(days=1)

    frame = pd.DataFrame.from_records(
        [
            {
                "sid": 0,
                "symbol": "duplicated",
                "start_date": dupe_0_start.value,
                "end_date": dupe_0_end.value,
                "exchange": "",
            },
            {
                "sid": 1,
                "symbol": "duplicated",
                "start_date": dupe_1_start.value,
                "end_date": dupe_1_end.value,
                "exchange": "",
            },
            {
                "sid": 2,
                "symbol": "unique",
                "start_date": unique_start.value,
                "end_date": unique_end.value,
                "exchange": "",
            },
        ],
        index="sid",
    )
    env = TradingEnvironment()
    env.write_data(equities_df=frame)
    finder = env.asset_finder
    dupe_0, dupe_1, unique = assets = [finder.retrieve_asset(i) for i in range(3)]

    dupe_0_start = dupe_0.start_date
    dupe_1_start = dupe_1.start_date
    cases = [
        ##
        # Scalars
        # Asset object
        (finder, assets[0], None, assets[0]),
        (finder, assets[1], None, assets[1]),
        (finder, assets[2], None, assets[2]),
        # int
        (finder, 0, None, assets[0]),
        (finder, 1, None, assets[1]),
        (finder, 2, None, assets[2]),
        # Duplicated symbol with resolution date
        (finder, "DUPLICATED", dupe_0_start, dupe_0),
        (finder, "DUPLICATED", dupe_1_start, dupe_1),
        # Unique symbol, with or without resolution date.
        (finder, "UNIQUE", unique_start, unique),
        (finder, "UNIQUE", None, unique),
        ##
        # Iterables
        # Iterables of Asset objects.
        (finder, assets, None, assets),
        (finder, iter(assets), None, assets),
        # Iterables of ints
        (finder, (0, 1), None, assets[:-1]),
        (finder, iter((0, 1)), None, assets[:-1]),
        # Iterables of symbols.
        (finder, ("DUPLICATED", "UNIQUE"), dupe_0_start, [dupe_0, unique]),
        (finder, ("DUPLICATED", "UNIQUE"), dupe_1_start, [dupe_1, unique]),
        # Mixed types
        (finder, ("DUPLICATED", 2, "UNIQUE", 1, dupe_1), dupe_0_start, [dupe_0, assets[2], unique, assets[1], dupe_1]),
    ]
    return cases

# 需要导入模块: from zipline.finance.trading import TradingEnvironment [as 别名]
# 或者: from zipline.finance.trading.TradingEnvironment import write_data [as 别名]
class AssetFinderTestCase(TestCase):
    def setUp(self):
        self.env = TradingEnvironment(load=noop_load)

    def test_lookup_symbol_delimited(self):
        as_of = pd.Timestamp("2013-01-01", tz="UTC")
        frame = pd.DataFrame.from_records(
            [
                {
                    "sid": i,
                    "symbol": "TEST.%d" % i,
                    "company_name": "company%d" % i,
                    "start_date": as_of.value,
                    "end_date": as_of.value,
                    "exchange": uuid.uuid4().hex,
                }
                for i in range(3)
            ]
        )
        self.env.write_data(equities_df=frame)
        finder = AssetFinder(self.env.engine)
        asset_0, asset_1, asset_2 = (finder.retrieve_asset(i) for i in range(3))

        # we do it twice to catch caching bugs
        for i in range(2):
            with self.assertRaises(SymbolNotFound):
                finder.lookup_symbol("TEST", as_of)
            with self.assertRaises(SymbolNotFound):
                finder.lookup_symbol("TEST1", as_of)
            # '@' is not a supported delimiter
            with self.assertRaises(SymbolNotFound):
                finder.lookup_symbol("[email protected]", as_of)

            # Adding an unnecessary fuzzy shouldn't matter.
            for fuzzy_char in ["-", "/", "_", "."]:
                self.assertEqual(asset_1, finder.lookup_symbol("TEST%s1" % fuzzy_char, as_of))

    def test_lookup_symbol_fuzzy(self):
        metadata = {0: {"symbol": "PRTY_HRD"}, 1: {"symbol": "BRKA"}, 2: {"symbol": "BRK_A"}}
        self.env.write_data(equities_data=metadata)
        finder = self.env.asset_finder
        dt = pd.Timestamp("2013-01-01", tz="UTC")

        # Try combos of looking up PRTYHRD with and without a time or fuzzy
        # Both non-fuzzys get no result
        with self.assertRaises(SymbolNotFound):
            finder.lookup_symbol("PRTYHRD", None)
        with self.assertRaises(SymbolNotFound):
            finder.lookup_symbol("PRTYHRD", dt)
        # Both fuzzys work
        self.assertEqual(0, finder.lookup_symbol("PRTYHRD", None, fuzzy=True))
        self.assertEqual(0, finder.lookup_symbol("PRTYHRD", dt, fuzzy=True))

        # Try combos of looking up PRTY_HRD, all returning sid 0
        self.assertEqual(0, finder.lookup_symbol("PRTY_HRD", None))
        self.assertEqual(0, finder.lookup_symbol("PRTY_HRD", dt))
        self.assertEqual(0, finder.lookup_symbol("PRTY_HRD", None, fuzzy=True))
        self.assertEqual(0, finder.lookup_symbol("PRTY_HRD", dt, fuzzy=True))

        # Try combos of looking up BRKA, all returning sid 1
        self.assertEqual(1, finder.lookup_symbol("BRKA", None))
        self.assertEqual(1, finder.lookup_symbol("BRKA", dt))
        self.assertEqual(1, finder.lookup_symbol("BRKA", None, fuzzy=True))
        self.assertEqual(1, finder.lookup_symbol("BRKA", dt, fuzzy=True))

        # Try combos of looking up BRK_A, all returning sid 2
        self.assertEqual(2, finder.lookup_symbol("BRK_A", None))
        self.assertEqual(2, finder.lookup_symbol("BRK_A", dt))
        self.assertEqual(2, finder.lookup_symbol("BRK_A", None, fuzzy=True))
        self.assertEqual(2, finder.lookup_symbol("BRK_A", dt, fuzzy=True))

    def test_lookup_symbol(self):

        # Incrementing by two so that start and end dates for each
        # generated Asset don't overlap (each Asset's end_date is the
        # day after its start date.)
        dates = pd.date_range("2013-01-01", freq="2D", periods=5, tz="UTC")
        df = pd.DataFrame.from_records(
            [
                {
                    "sid": i,
                    "symbol": "existing",
                    "start_date": date.value,
                    "end_date": (date + timedelta(days=1)).value,
                    "exchange": "NYSE",
                }
                for i, date in enumerate(dates)
            ]
        )
        self.env.write_data(equities_df=df)
        finder = AssetFinder(self.env.engine)
        for _ in range(2):  # Run checks twice to test for caching bugs.
            with self.assertRaises(SymbolNotFound):
                finder.lookup_symbol("NON_EXISTING", dates[0])

            with self.assertRaises(MultipleSymbolsFound):
                finder.lookup_symbol("EXISTING", None)

            for i, date in enumerate(dates):
                # Verify that we correctly resolve multiple symbols using
#.........这里部分代码省略.........