zipline.gens.AlgorithmSimulator._process_snapshot() - Code Metrics - quantopian/zipline - Measure and Improve Code Quality continuously with Scrutinizer

_process_snapshot() F
last analyzed 2016-01-08 22:03 UTC

↳ Parent: zipline.gens.AlgorithmSimulator

Complexity

Conditions

Size

Total Lines

158

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	34
dl	0
loc	158
rs	2

How to fix Long Method Complexity

#
# Copyright 2014 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.

from contextlib2 import ExitStack

from logbook import Logger, Processor
from pandas.tslib import normalize_date

from zipline.utils.api_support import ZiplineAPI

from zipline.finance.trading import NoFurtherDataError
from zipline.protocol import (
    BarData,
    SIDData,
    DATASOURCE_TYPE
)

log = Logger('Trade Simulation')


class AlgorithmSimulator(object):

    EMISSION_TO_PERF_KEY_MAP = {
        'minute': 'minute_perf',
        'daily': 'daily_perf'
    }

    def __init__(self, algo, sim_params):

        # ==============
        # Simulation
        # Param Setup
        # ==============
        self.sim_params = sim_params

        # ==============
        # Algo Setup
        # ==============
        self.algo = algo
        self.algo_start = normalize_date(self.sim_params.first_open)
        self.env = algo.trading_environment

        # ==============
        # Snapshot Setup
        # ==============

        # The algorithm's data as of our most recent event.
        # We want an object that will have empty objects as default
        # values on missing keys.
        self.current_data = BarData()

        # We don't have a datetime for the current snapshot until we
        # receive a message.
        self.simulation_dt = None

        # =============
        # Logging Setup
        # =============

        # Processor function for injecting the algo_dt into
        # user prints/logs.
        def inject_algo_dt(record):
            if 'algo_dt' not in record.extra:
                record.extra['algo_dt'] = self.simulation_dt
        self.processor = Processor(inject_algo_dt)

    def transform(self, stream_in):
        """
        Main generator work loop.
        """
        # Initialize the mkt_close
        mkt_open = self.algo.perf_tracker.market_open
        mkt_close = self.algo.perf_tracker.market_close

        # inject the current algo
        # snapshot time to any log record generated.

        with ExitStack() as stack:
            stack.enter_context(self.processor)
            stack.enter_context(ZiplineAPI(self.algo))

            data_frequency = self.sim_params.data_frequency

            self._call_before_trading_start(mkt_open)

            for date, snapshot in stream_in:

                self.simulation_dt = date
                self.on_dt_changed(date)

                # If we're still in the warmup period.  Use the event to
                # update our universe, but don't yield any perf messages,
                # and don't send a snapshot to handle_data.
                if date < self.algo_start:
                    for event in snapshot:
                        if event.type == DATASOURCE_TYPE.SPLIT:
                            self.algo.blotter.process_split(event)

                        elif event.type == DATASOURCE_TYPE.TRADE:
                            self.update_universe(event)
                            self.algo.perf_tracker.process_trade(event)
                        elif event.type == DATASOURCE_TYPE.CUSTOM:
                            self.update_universe(event)

                else:
                    messages = self._process_snapshot(
                        date,
                        snapshot,
                        self.algo.instant_fill,
                    )
                    # Perf messages are only emitted if the snapshot contained
                    # a benchmark event.
                    for message in messages:
                        yield message

                    # When emitting minutely, we need to call
                    # before_trading_start before the next trading day begins
                    if date == mkt_close:
                        if mkt_close <= self.algo.perf_tracker.last_close:
                            before_last_close = \
                                mkt_close < self.algo.perf_tracker.last_close
                            try:
                                mkt_open, mkt_close = \
                                    self.env.next_open_and_close(mkt_close)

                            except NoFurtherDataError:
                                # If at the end of backtest history,
                                # skip advancing market close.
                                pass

                            if before_last_close:
                                self._call_before_trading_start(mkt_open)

                    elif data_frequency == 'daily':
                        next_day = self.env.next_trading_day(date)

                        if next_day is not None and \
                           next_day < self.algo.perf_tracker.last_close:
                            self._call_before_trading_start(next_day)

                    self.algo.portfolio_needs_update = True
                    self.algo.account_needs_update = True
                    self.algo.performance_needs_update = True

            risk_message = self.algo.perf_tracker.handle_simulation_end()
            yield risk_message

    def _process_snapshot(self, dt, snapshot, instant_fill):
        """
        Process a stream of events corresponding to a single datetime, possibly
        returning a perf message to be yielded.

        If @instant_fill = True, we delay processing of events until after the
        user's call to handle_data, and we process the user's placed orders
        before the snapshot's events.  Note that this introduces a lookahead
        bias, since the user effectively is effectively placing orders that are
        filled based on trades that happened prior to the call the handle_data.

        If @instant_fill = False, we process Trade events before calling
        handle_data.  This means that orders are filled based on trades
        occurring in the next snapshot.  This is the more conservative model,
        and as such it is the default behavior in TradingAlgorithm.
        """

        # Flags indicating whether we saw any events of type TRADE and type
        # BENCHMARK.  Respectively, these control whether or not handle_data is
        # called for this snapshot and whether we emit a perf message for this
        # snapshot.
        any_trade_occurred = False
        benchmark_event_occurred = False

        if instant_fill:
            events_to_be_processed = []

        # Assign process events to variables to avoid attribute access in
        # innermost loops.
        #
        # Done here, to allow for perf_tracker or blotter to be swapped out
        # or changed in between snapshots.
        perf_process_trade = self.algo.perf_tracker.process_trade
        perf_process_transaction = self.algo.perf_tracker.process_transaction
        perf_process_order = self.algo.perf_tracker.process_order
        perf_process_benchmark = self.algo.perf_tracker.process_benchmark
        perf_process_split = self.algo.perf_tracker.process_split
        perf_process_dividend = self.algo.perf_tracker.process_dividend
        perf_process_commission = self.algo.perf_tracker.process_commission
        perf_process_close_position = \
            self.algo.perf_tracker.process_close_position
        blotter_process_trade = self.algo.blotter.process_trade
        blotter_process_benchmark = self.algo.blotter.process_benchmark

        # Containers for the snapshotted events, so that the events are
        # processed in a predictable order, without relying on the sorted order
        # of the individual sources.

        # There is only one benchmark per snapshot, will be set to the current
        # benchmark iff it occurs.
        benchmark = None
        # trades and customs are initialized as a list since process_snapshot
        # is most often called on market bars, which could contain trades or
        # custom events.
        trades = []
        customs = []
        closes = []

        # splits and dividends are processed once a day.
        #
        # The avoidance of creating the list every time this is called is more
        # to attempt to show that this is the infrequent case of the method,
        # since the performance benefit from deferring the list allocation is
        # marginal.  splits list will be allocated when a split occurs in the
        # snapshot.
        splits = None
        # dividends list will be allocated when a dividend occurs in the
        # snapshot.
        dividends = None

        for event in snapshot:
            if event.type == DATASOURCE_TYPE.TRADE:
                trades.append(event)
            elif event.type == DATASOURCE_TYPE.BENCHMARK:
                benchmark = event
            elif event.type == DATASOURCE_TYPE.SPLIT:
                if splits is None:
                    splits = []
                splits.append(event)
            elif event.type == DATASOURCE_TYPE.CUSTOM:
                customs.append(event)
            elif event.type == DATASOURCE_TYPE.DIVIDEND:
                if dividends is None:
                    dividends = []
                dividends.append(event)
            elif event.type == DATASOURCE_TYPE.CLOSE_POSITION:
                closes.append(event)
            else:
                raise log.warn("Unrecognized event=%s".format(event))

        # Handle benchmark first.
        #
        # Internal broker implementation depends on the benchmark being
        # processed first so that transactions and commissions reported from
        # the broker can be injected.
        if benchmark is not None:
            benchmark_event_occurred = True
            perf_process_benchmark(benchmark)
            for txn, order in blotter_process_benchmark(benchmark):
                if txn.type == DATASOURCE_TYPE.TRANSACTION:
                    perf_process_transaction(txn)
                elif txn.type == DATASOURCE_TYPE.COMMISSION:
                    perf_process_commission(txn)
                perf_process_order(order)

        for trade in trades:
            self.update_universe(trade)
            any_trade_occurred = True
            if instant_fill:
                events_to_be_processed.append(trade)
            else:
                for txn, order in blotter_process_trade(trade):
                    if txn.type == DATASOURCE_TYPE.TRANSACTION:
                        perf_process_transaction(txn)
                    elif txn.type == DATASOURCE_TYPE.COMMISSION:
                        perf_process_commission(txn)
                    perf_process_order(order)
                perf_process_trade(trade)

        for custom in customs:
            self.update_universe(custom)

        for close in closes:
            self.update_universe(close)
            perf_process_close_position(close)

        if splits is not None:
            for split in splits:
                # process_split is not assigned to a variable since it is
                # called rarely compared to the other event processors.
                self.algo.blotter.process_split(split)
                perf_process_split(split)

        if dividends is not None:
            for dividend in dividends:
                perf_process_dividend(dividend)

        if any_trade_occurred:
            new_orders = self._call_handle_data()
            for order in new_orders:
                perf_process_order(order)

        if instant_fill:
            # Now that handle_data has been called and orders have been placed,
            # process the event stream to fill user orders based on the events
            # from this snapshot.
            for trade in events_to_be_processed:
                for txn, order in blotter_process_trade(trade):
                    if txn is not None:
                        perf_process_transaction(txn)
                    if order is not None:
                        perf_process_order(order)
                perf_process_trade(trade)

        if benchmark_event_occurred:
            return self.generate_messages(dt)
        else:
            return ()

    def _call_handle_data(self):
        """
        Call the user's handle_data, returning any orders placed by the algo
        during the call.
        """
        self.algo.event_manager.handle_data(
            self.algo,
            self.current_data,
            self.simulation_dt,
        )
        orders = self.algo.blotter.new_orders
        self.algo.blotter.new_orders = []
        return orders

    def _call_before_trading_start(self, dt):
        dt = normalize_date(dt)
        self.simulation_dt = dt
        self.on_dt_changed(dt)
        self.algo.before_trading_start(self.current_data)

    def on_dt_changed(self, dt):
        if self.algo.datetime != dt:
            self.algo.on_dt_changed(dt)

    def generate_messages(self, dt):
        """
        Generator that yields perf messages for the given datetime.
        """
        # Ensure that updated_portfolio has been called at least once for this
        # dt before we emit a perf message.  This is a no-op if
        # updated_portfolio has already been called this dt.
        self.algo.updated_portfolio()
        self.algo.updated_account()

        rvars = self.algo.recorded_vars
        if self.algo.perf_tracker.emission_rate == 'daily':
            perf_message = \
                self.algo.perf_tracker.handle_market_close_daily()
            perf_message['daily_perf']['recorded_vars'] = rvars
            yield perf_message

        elif self.algo.perf_tracker.emission_rate == 'minute':
            # close the minute in the tracker, and collect the daily message if
            # the minute is the close of the trading day
            minute_message, daily_message = \
                self.algo.perf_tracker.handle_minute_close(dt)

            # collect and yield the minute's perf message
            minute_message['minute_perf']['recorded_vars'] = rvars
            yield minute_message

            # if there was a daily perf message, collect and yield it
            if daily_message:
                daily_message['daily_perf']['recorded_vars'] = rvars
                yield daily_message

    def update_universe(self, event):
        """
        Update the universe with new event information.
        """
        # Update our knowledge of this event's sid
        # rather than use if event.sid in ..., just trying
        # and handling the exception is significantly faster
        try:
            sid_data = self.current_data[event.sid]
        except KeyError:
            sid_data = self.current_data[event.sid] = SIDData(event.sid)

        sid_data.__dict__.update(event.__dict__)


1			#
2			# Copyright 2014 Quantopian, Inc.
3			#
4			# Licensed under the Apache License, Version 2.0 (the "License");
5			# you may not use this file except in compliance with the License.
6			# You may obtain a copy of the License at
7			#
8			# http://www.apache.org/licenses/LICENSE-2.0
9			#
10			# Unless required by applicable law or agreed to in writing, software
11			# distributed under the License is distributed on an "AS IS" BASIS,
12			# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13			# See the License for the specific language governing permissions and
14			# limitations under the License.
15
16			from contextlib2 import ExitStack
17
18			from logbook import Logger, Processor
19			from pandas.tslib import normalize_date
20
21			from zipline.utils.api_support import ZiplineAPI
22
23			from zipline.finance.trading import NoFurtherDataError
24			from zipline.protocol import (
25			BarData,
26			SIDData,
27			DATASOURCE_TYPE
28			)
29
30			log = Logger('Trade Simulation')
31
32
33			class AlgorithmSimulator(object):
34
35			EMISSION_TO_PERF_KEY_MAP = {
36			'minute': 'minute_perf',
37			'daily': 'daily_perf'
38			}
39
40			def __init__(self, algo, sim_params):
41
42			# ==============
43			# Simulation
44			# Param Setup
45			# ==============
46			self.sim_params = sim_params
47
48			# ==============
49			# Algo Setup
50			# ==============
51			self.algo = algo
52			self.algo_start = normalize_date(self.sim_params.first_open)
53			self.env = algo.trading_environment
54
55			# ==============
56			# Snapshot Setup
57			# ==============
58
59			# The algorithm's data as of our most recent event.
60			# We want an object that will have empty objects as default
61			# values on missing keys.
62			self.current_data = BarData()
63
64			# We don't have a datetime for the current snapshot until we
65			# receive a message.
66			self.simulation_dt = None
67
68			# =============
69			# Logging Setup
70			# =============
71
72			# Processor function for injecting the algo_dt into
73			# user prints/logs.
74			def inject_algo_dt(record):
75			if 'algo_dt' not in record.extra:
76			record.extra['algo_dt'] = self.simulation_dt
77			self.processor = Processor(inject_algo_dt)
78
79			def transform(self, stream_in):
80			"""
81			Main generator work loop.
82			"""
83			# Initialize the mkt_close
84			mkt_open = self.algo.perf_tracker.market_open
85			mkt_close = self.algo.perf_tracker.market_close
86
87			# inject the current algo
88			# snapshot time to any log record generated.
89
90			with ExitStack() as stack:
91			stack.enter_context(self.processor)
92			stack.enter_context(ZiplineAPI(self.algo))
93
94			data_frequency = self.sim_params.data_frequency
95
96			self._call_before_trading_start(mkt_open)
97
98			for date, snapshot in stream_in:
99
100			self.simulation_dt = date
101			self.on_dt_changed(date)
102
103			# If we're still in the warmup period. Use the event to
104			# update our universe, but don't yield any perf messages,
105			# and don't send a snapshot to handle_data.
106			if date < self.algo_start:
107			for event in snapshot:
108			if event.type == DATASOURCE_TYPE.SPLIT:
109			self.algo.blotter.process_split(event)
110
111			elif event.type == DATASOURCE_TYPE.TRADE:
112			self.update_universe(event)
113			self.algo.perf_tracker.process_trade(event)
114			elif event.type == DATASOURCE_TYPE.CUSTOM:
115			self.update_universe(event)
116
117			else:
118			messages = self._process_snapshot(
119			date,
120			snapshot,
121			self.algo.instant_fill,
122			)
123			# Perf messages are only emitted if the snapshot contained
124			# a benchmark event.
125			for message in messages:
126			yield message
127
128			# When emitting minutely, we need to call
129			# before_trading_start before the next trading day begins
130			if date == mkt_close:
131			if mkt_close <= self.algo.perf_tracker.last_close:
132			before_last_close = \
133			mkt_close < self.algo.perf_tracker.last_close
134			try:
135			mkt_open, mkt_close = \
136			self.env.next_open_and_close(mkt_close)
137
138			except NoFurtherDataError:
139			# If at the end of backtest history,
140			# skip advancing market close.
141			pass
142
143			if before_last_close:
144			self._call_before_trading_start(mkt_open)
145
146			elif data_frequency == 'daily':
147			next_day = self.env.next_trading_day(date)
148
149			if next_day is not None and \
150			next_day < self.algo.perf_tracker.last_close:
151			self._call_before_trading_start(next_day)
152
153			self.algo.portfolio_needs_update = True
154			self.algo.account_needs_update = True
155			self.algo.performance_needs_update = True
156
157			risk_message = self.algo.perf_tracker.handle_simulation_end()
158			yield risk_message
159
160			def _process_snapshot(self, dt, snapshot, instant_fill):
161			"""
162			Process a stream of events corresponding to a single datetime, possibly
163			returning a perf message to be yielded.
164
165			If @instant_fill = True, we delay processing of events until after the
166			user's call to handle_data, and we process the user's placed orders
167			before the snapshot's events. Note that this introduces a lookahead
168			bias, since the user effectively is effectively placing orders that are
169			filled based on trades that happened prior to the call the handle_data.
170
171			If @instant_fill = False, we process Trade events before calling
172			handle_data. This means that orders are filled based on trades
173			occurring in the next snapshot. This is the more conservative model,
174			and as such it is the default behavior in TradingAlgorithm.
175			"""
176
177			# Flags indicating whether we saw any events of type TRADE and type
178			# BENCHMARK. Respectively, these control whether or not handle_data is
179			# called for this snapshot and whether we emit a perf message for this
180			# snapshot.
181			any_trade_occurred = False
182			benchmark_event_occurred = False
183
184			if instant_fill:
185			events_to_be_processed = []
186
187			# Assign process events to variables to avoid attribute access in
188			# innermost loops.
189			#
190			# Done here, to allow for perf_tracker or blotter to be swapped out
191			# or changed in between snapshots.
192			perf_process_trade = self.algo.perf_tracker.process_trade
193			perf_process_transaction = self.algo.perf_tracker.process_transaction
194			perf_process_order = self.algo.perf_tracker.process_order
195			perf_process_benchmark = self.algo.perf_tracker.process_benchmark
196			perf_process_split = self.algo.perf_tracker.process_split
197			perf_process_dividend = self.algo.perf_tracker.process_dividend
198			perf_process_commission = self.algo.perf_tracker.process_commission
199			perf_process_close_position = \
200			self.algo.perf_tracker.process_close_position
201			blotter_process_trade = self.algo.blotter.process_trade
202			blotter_process_benchmark = self.algo.blotter.process_benchmark
203
204			# Containers for the snapshotted events, so that the events are
205			# processed in a predictable order, without relying on the sorted order
206			# of the individual sources.
207
208			# There is only one benchmark per snapshot, will be set to the current
209			# benchmark iff it occurs.
210			benchmark = None
211			# trades and customs are initialized as a list since process_snapshot
212			# is most often called on market bars, which could contain trades or
213			# custom events.
214			trades = []
215			customs = []
216			closes = []
217
218			# splits and dividends are processed once a day.
219			#
220			# The avoidance of creating the list every time this is called is more
221			# to attempt to show that this is the infrequent case of the method,
222			# since the performance benefit from deferring the list allocation is
223			# marginal. splits list will be allocated when a split occurs in the
224			# snapshot.
225			splits = None
226			# dividends list will be allocated when a dividend occurs in the
227			# snapshot.
228			dividends = None
229
230			for event in snapshot:
231			if event.type == DATASOURCE_TYPE.TRADE:
232			trades.append(event)
233			elif event.type == DATASOURCE_TYPE.BENCHMARK:
234			benchmark = event
235			elif event.type == DATASOURCE_TYPE.SPLIT:
236			if splits is None:
237			splits = []
238			splits.append(event)
239			elif event.type == DATASOURCE_TYPE.CUSTOM:
240			customs.append(event)
241			elif event.type == DATASOURCE_TYPE.DIVIDEND:
242			if dividends is None:
243			dividends = []
244			dividends.append(event)
245			elif event.type == DATASOURCE_TYPE.CLOSE_POSITION:
246			closes.append(event)
247			else:
248			raise log.warn("Unrecognized event=%s".format(event))
249
250			# Handle benchmark first.
251			#
252			# Internal broker implementation depends on the benchmark being
253			# processed first so that transactions and commissions reported from
254			# the broker can be injected.
255			if benchmark is not None:
256			benchmark_event_occurred = True
257			perf_process_benchmark(benchmark)
258			for txn, order in blotter_process_benchmark(benchmark):
259			if txn.type == DATASOURCE_TYPE.TRANSACTION:
260			perf_process_transaction(txn)
261			elif txn.type == DATASOURCE_TYPE.COMMISSION:
262			perf_process_commission(txn)
263			perf_process_order(order)
264
265			for trade in trades:
266			self.update_universe(trade)
267			any_trade_occurred = True
268			if instant_fill:
269			events_to_be_processed.append(trade)
270			else:
271			for txn, order in blotter_process_trade(trade):
272			if txn.type == DATASOURCE_TYPE.TRANSACTION:
273			perf_process_transaction(txn)
274			elif txn.type == DATASOURCE_TYPE.COMMISSION:
275			perf_process_commission(txn)
276			perf_process_order(order)
277			perf_process_trade(trade)
278
279			for custom in customs:
280			self.update_universe(custom)
281
282			for close in closes:
283			self.update_universe(close)
284			perf_process_close_position(close)
285
286			if splits is not None:
287			for split in splits:
288			# process_split is not assigned to a variable since it is
289			# called rarely compared to the other event processors.
290			self.algo.blotter.process_split(split)
291			perf_process_split(split)
292
293			if dividends is not None:
294			for dividend in dividends:
295			perf_process_dividend(dividend)
296
297			if any_trade_occurred:
298			new_orders = self._call_handle_data()
299			for order in new_orders:
300			perf_process_order(order)
301
302			if instant_fill:
303			# Now that handle_data has been called and orders have been placed,
304			# process the event stream to fill user orders based on the events
305			# from this snapshot.
306			for trade in events_to_be_processed:
307			for txn, order in blotter_process_trade(trade):
308			if txn is not None:
309			perf_process_transaction(txn)
310			if order is not None:
311			perf_process_order(order)
312			perf_process_trade(trade)
313
314			if benchmark_event_occurred:
315			return self.generate_messages(dt)
316			else:
317			return ()
318
319			def _call_handle_data(self):
320			"""
321			Call the user's handle_data, returning any orders placed by the algo
322			during the call.
323			"""
324			self.algo.event_manager.handle_data(
325			self.algo,
326			self.current_data,
327			self.simulation_dt,
328			)
329			orders = self.algo.blotter.new_orders
330			self.algo.blotter.new_orders = []
331			return orders
332
333			def _call_before_trading_start(self, dt):
334			dt = normalize_date(dt)
335			self.simulation_dt = dt
336			self.on_dt_changed(dt)
337			self.algo.before_trading_start(self.current_data)
338
339			def on_dt_changed(self, dt):
340			if self.algo.datetime != dt:
341			self.algo.on_dt_changed(dt)
342
343			def generate_messages(self, dt):
344			"""
345			Generator that yields perf messages for the given datetime.
346			"""
347			# Ensure that updated_portfolio has been called at least once for this
348			# dt before we emit a perf message. This is a no-op if
349			# updated_portfolio has already been called this dt.
350			self.algo.updated_portfolio()
351			self.algo.updated_account()
352
353			rvars = self.algo.recorded_vars
354			if self.algo.perf_tracker.emission_rate == 'daily':
355			perf_message = \
356			self.algo.perf_tracker.handle_market_close_daily()
357			perf_message['daily_perf']['recorded_vars'] = rvars
358			yield perf_message
359
360			elif self.algo.perf_tracker.emission_rate == 'minute':
361			# close the minute in the tracker, and collect the daily message if
362			# the minute is the close of the trading day
363			minute_message, daily_message = \
364			self.algo.perf_tracker.handle_minute_close(dt)
365
366			# collect and yield the minute's perf message
367			minute_message['minute_perf']['recorded_vars'] = rvars
368			yield minute_message
369
370			# if there was a daily perf message, collect and yield it
371			if daily_message:
372			daily_message['daily_perf']['recorded_vars'] = rvars
373			yield daily_message
374
375			def update_universe(self, event):
376			"""
377			Update the universe with new event information.
378			"""
379			# Update our knowledge of this event's sid
380			# rather than use if event.sid in ..., just trying
381			# and handling the exception is significantly faster
382			try:
383			sid_data = self.current_data[event.sid]
384			except KeyError:
385			sid_data = self.current_data[event.sid] = SIDData(event.sid)
386
387			sid_data.__dict__.update(event.__dict__)
388

quantopian / zipline

_process_snapshot() F last analyzed 2016-01-08 22:03 UTC

Complexity

Size

Duplication

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like

_process_snapshot() F
last analyzed 2016-01-08 22:03 UTC