1038

pending completion

Build # 1038

Build Type

push

travis-ci

Committed by

Cuizi7

Commit Message

<a href="https://github.com/ricequant/rqalpha/commit/<a class=hub.com/ricequant/rqalpha/commit/<a class="double-link" href="https://git"><a class=hub.com/ricequant/rqalpha/commit/<a class="double-link" href="https://git"><a class=hub.com/ricequant/rqalpha/commit/<a class="double-link" href="https://git"><a class=hub.com/ricequant/rqalpha/commit/<a class="double-link" href="https://git"><a class=hub.com/ricequant/rqalpha/commit/<a class="double-link" href="https://git"><a class=hub.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316">6b744bf44">&lt;a href=&quot;https://github.com/ricequant/rqalpha/commit/</a><a class="double-link" href="https://github.com/ricequant/rqalpha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ricequant/rqalpha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ricequant/rqalpha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ricequant/rqalpha/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316">6b744bf44</a><a href="https://github.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316">&lt;a href=&quot;https://github.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/ricequant/rqalpha/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/ricequant/rqalpha/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316&amp;quot;&amp;gt;6b744bf44&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/ricequant/rqalpha/commit/6b744bf44330307af5c8c6eeab63d5a60675a316&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;quot;&amp;amp;amp;gt;Revert &amp;amp;amp;amp;quot;change initial calendar_dt to real datetime in pt * rt&amp;amp;amp;amp;quot;

This reverts commit &amp;amp;amp;lt;/a&amp;amp;amp;gt;&amp;amp;amp;lt;a class=&amp;amp;amp;quot;double-link&amp;amp;amp;quot; href=&amp;amp;amp;quot;https://git... (continued)

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

4629 of 7759 relevant lines covered (59.66%)

2.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.26

/rqalpha/main.py

# -*- coding: utf-8 -*-
#
# Copyright 2017 Ricequant, 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.

import os
import sys
import tarfile
import tempfile
import datetime
import shutil
from pprint import pformat

import logbook
import click
import jsonpickle.ext.numpy as jsonpickle_numpy
import pytz
import requests
import six

from rqalpha import const
from rqalpha.api import helper as api_helper
from rqalpha.core.strategy_loader import FileStrategyLoader, SourceCodeStrategyLoader, UserFuncStrategyLoader
from rqalpha.core.strategy import Strategy
from rqalpha.core.strategy_universe import StrategyUniverse
from rqalpha.core.global_var import GlobalVars
from rqalpha.core.strategy_context import StrategyContext
from rqalpha.data.base_data_source import BaseDataSource
from rqalpha.data.data_proxy import DataProxy
from rqalpha.environment import Environment
from rqalpha.events import EVENT, Event
from rqalpha.execution_context import ExecutionContext
from rqalpha.interface import Persistable
from rqalpha.mod import ModHandler
from rqalpha.model.bar import BarMap
from rqalpha.model.portfolio import Portfolio
from rqalpha.model.base_position import Positions
from rqalpha.utils import create_custom_exception, run_with_user_log_disabled, scheduler as mod_scheduler
from rqalpha.utils.exception import CustomException, is_user_exc, patch_user_exc
from rqalpha.utils.i18n import gettext as _
from rqalpha.utils.persisit_helper import CoreObjectsPersistProxy, PersistHelper
from rqalpha.utils.scheduler import Scheduler
from rqalpha.utils.config import set_locale
from rqalpha.utils.logger import system_log, basic_system_log, user_system_log, user_detail_log


jsonpickle_numpy.register_handlers()


def _adjust_start_date(config, data_proxy):
    origin_start_date, origin_end_date = config.base.start_date, config.base.end_date
    start, end = data_proxy.available_data_range(config.base.frequency)

    config.base.start_date = max(start, config.base.start_date)
    config.base.end_date = min(end, config.base.end_date)
    config.base.trading_calendar = data_proxy.get_trading_dates(config.base.start_date, config.base.end_date)
    if len(config.base.trading_calendar) == 0:
        raise patch_user_exc(
            ValueError(
                _(u"There is no data between {start_date} and {end_date}. Please check your"
                  u" data bundle or select other backtest period.").format(
                      start_date=origin_start_date, end_date=origin_end_date)))
    config.base.start_date = config.base.trading_calendar[0].date()
    config.base.end_date = config.base.trading_calendar[-1].date()
    config.base.timezone = pytz.utc


def _validate_benchmark(config, data_proxy):
    benchmark = config.base.benchmark
    if benchmark is None:
        return
    instrument = data_proxy.instruments(benchmark)
    if instrument is None:
        raise patch_user_exc(ValueError(_(u"invalid benchmark {}").format(benchmark)))

    if instrument.order_book_id == "000300.XSHG":
        # 000300.XSHG 数据进行了补齐，因此认为只要benchmark设置了000300.XSHG，就存在数据，不受限于上市日期。
        return
    config = Environment.get_instance().config
    start_date = config.base.start_date
    end_date = config.base.end_date
    if instrument.listed_date.date() > start_date:
        raise patch_user_exc(ValueError(
            _(u"benchmark {benchmark} has not been listed on {start_date}").format(benchmark=benchmark,
                                                                                   start_date=start_date)))
    if instrument.de_listed_date.date() < end_date:
        raise patch_user_exc(ValueError(
            _(u"benchmark {benchmark} has been de_listed on {end_date}").format(benchmark=benchmark,
                                                                                end_date=end_date)))


def create_benchmark_portfolio(env):
    if env.config.base.benchmark is None:
        return None

    BenchmarkAccount = env.get_account_model(const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name)
    BenchmarkPosition = env.get_position_model(const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name)

    start_date = env.config.base.start_date
    total_cash = sum(env.config.base.accounts.values())
    accounts = {
        const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name: BenchmarkAccount(total_cash, Positions(BenchmarkPosition))
    }
    return Portfolio(start_date, 1, total_cash, accounts)


def create_base_scope():
    import copy
    from rqalpha.utils.logger import user_print, user_log

    from . import user_module
    scope = copy.copy(user_module.__dict__)
    scope.update({
        "logger": user_log,
        "print": user_print,
    })

    return scope


def update_bundle(data_bundle_path=None, locale="zh_Hans_CN", confirm=True):
    set_locale(locale)
    default_bundle_path = os.path.abspath(os.path.expanduser('~/.rqalpha/bundle'))
    if data_bundle_path is None:
        data_bundle_path = default_bundle_path
    else:
        data_bundle_path = os.path.abspath(os.path.join(data_bundle_path, './bundle/'))
    if (confirm and os.path.exists(data_bundle_path) and data_bundle_path != default_bundle_path and
            os.listdir(data_bundle_path)):
        click.confirm(_(u"""
[WARNING]
Target bundle path {data_bundle_path} is not empty.
The content of this folder will be REMOVED before updating.
Are you sure to continue?""").format(data_bundle_path=data_bundle_path), abort=True)

    day = datetime.date.today()
    tmp = os.path.join(tempfile.gettempdir(), 'rq.bundle')

    while True:
        url = 'http://7xjci3.com1.z0.glb.clouddn.com/bundles_v3/rqbundle_%04d%02d%02d.tar.bz2' % (
            day.year, day.month, day.day)
        six.print_(_(u"try {} ...").format(url))
        r = requests.get(url, stream=True)
        if r.status_code != 200:
            day = day - datetime.timedelta(days=1)
            continue

        out = open(tmp, 'wb')
        total_length = int(r.headers.get('content-length'))

        with click.progressbar(length=total_length, label=_(u"downloading ...")) as bar:
            for data in r.iter_content(chunk_size=8192):
                bar.update(len(data))
                out.write(data)

        out.close()
        break

    shutil.rmtree(data_bundle_path, ignore_errors=True)
    os.makedirs(data_bundle_path)
    tar = tarfile.open(tmp, 'r:bz2')
    tar.extractall(data_bundle_path)
    tar.close()
    os.remove(tmp)
    six.print_(_(u"Data bundle download successfully in {bundle_path}").format(bundle_path=data_bundle_path))


def run(config, source_code=None, user_funcs=None):
    env = Environment(config)
    persist_helper = None
    init_succeed = False
    mod_handler = ModHandler()

    try:
        # avoid register handlers everytime
        # when running in ipython
        set_loggers(config)
        basic_system_log.debug("\n" + pformat(config.convert_to_dict()))

        if source_code is not None:
            env.set_strategy_loader(SourceCodeStrategyLoader(source_code))
        elif user_funcs is not None:
            env.set_strategy_loader(UserFuncStrategyLoader(user_funcs))
        else:
            env.set_strategy_loader(FileStrategyLoader(config.base.strategy_file))
        env.set_global_vars(GlobalVars())
        mod_handler.set_env(env)
        mod_handler.start_up()

        if not env.data_source:
            env.set_data_source(BaseDataSource(config.base.data_bundle_path))
        env.set_data_proxy(DataProxy(env.data_source))

        Scheduler.set_trading_dates_(env.data_source.get_trading_calendar())
        scheduler = Scheduler(config.base.frequency)
        mod_scheduler._scheduler = scheduler

        env._universe = StrategyUniverse()

        _adjust_start_date(env.config, env.data_proxy)

        _validate_benchmark(env.config, env.data_proxy)

        # FIXME
        start_dt = datetime.datetime.combine(config.base.start_date, datetime.datetime.min.time())
        env.calendar_dt = start_dt
        env.trading_dt = start_dt

        broker = env.broker
        assert broker is not None
        env.portfolio = broker.get_portfolio()
        env.benchmark_portfolio = create_benchmark_portfolio(env)

        event_source = env.event_source
        assert event_source is not None

        bar_dict = BarMap(env.data_proxy, config.base.frequency)
        env.set_bar_dict(bar_dict)

        if env.price_board is None:
            from .core.bar_dict_price_board import BarDictPriceBoard
            env.price_board = BarDictPriceBoard()

        ctx = ExecutionContext(const.EXECUTION_PHASE.GLOBAL)
        ctx._push()

        env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_INIT))

        scope = create_base_scope()
        scope.update({
            "g": env.global_vars
        })

        apis = api_helper.get_apis()
        scope.update(apis)

        scope = env.strategy_loader.load(scope)

        if env.config.extra.enable_profiler:
            enable_profiler(env, scope)

        ucontext = StrategyContext()
        user_strategy = Strategy(env.event_bus, scope, ucontext)
        scheduler.set_user_context(ucontext)

        if not config.extra.force_run_init_when_pt_resume:
            with run_with_user_log_disabled(disabled=config.base.resume_mode):
                user_strategy.init()

        if config.extra.context_vars:
            for k, v in six.iteritems(config.extra.context_vars):
                setattr(ucontext, k, v)

        if config.base.persist:
            persist_provider = env.persist_provider
            if persist_provider is None:
                raise RuntimeError(_(u"Missing persist provider. You need to set persist_provider before use persist"))
            persist_helper = PersistHelper(persist_provider, env.event_bus, config.base.persist_mode)
            env.set_persist_helper(persist_helper)
            persist_helper.register('core', CoreObjectsPersistProxy(scheduler))
            persist_helper.register('user_context', ucontext)
            persist_helper.register('global_vars', env.global_vars)
            persist_helper.register('universe', env._universe)
            if isinstance(event_source, Persistable):
                persist_helper.register('event_source', event_source)
            persist_helper.register('portfolio', env.portfolio)
            if env.benchmark_portfolio:
                persist_helper.register('benchmark_portfolio', env.benchmark_portfolio)
            for name, module in six.iteritems(env.mod_dict):
                if isinstance(module, Persistable):
                    persist_helper.register('mod_{}'.format(name), module)
            # broker will restore open orders from account
            if isinstance(broker, Persistable):
                persist_helper.register('broker', broker)

            env.event_bus.publish_event(Event(EVENT.BEFORE_SYSTEM_RESTORED))
            persist_helper.restore()
            env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_RESTORED))

        init_succeed = True

        # When force_run_init_when_pt_resume is active,
        # we should run `init` after restore persist data
        if config.extra.force_run_init_when_pt_resume:
            assert config.base.resume_mode == True
            with run_with_user_log_disabled(disabled=False):
                env._universe._set = set()
                user_strategy.init()

        from .core.executor import Executor
        Executor(env).run(bar_dict)

        if env.profile_deco:
            output_profile_result(env)
    except CustomException as e:
        if init_succeed and env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:
            persist_helper.persist()

        code = _exception_handler(e)
        mod_handler.tear_down(code, e)
    except Exception as e:
        if init_succeed and env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:
            persist_helper.persist()

        exc_type, exc_val, exc_tb = sys.exc_info()
        user_exc = create_custom_exception(exc_type, exc_val, exc_tb, config.base.strategy_file)

        code = _exception_handler(user_exc)
        mod_handler.tear_down(code, user_exc)
    else:
        if (env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_NORMAL_EXIT):
            persist_helper.persist()
        result = mod_handler.tear_down(const.EXIT_CODE.EXIT_SUCCESS)
        system_log.debug(_(u"strategy run successfully, normal exit"))
        return result


def _exception_handler(e):
    try:
        sys.excepthook(e.error.exc_type, e.error.exc_val, e.error.exc_tb)
    except Exception as e:
        system_log.exception("hook exception failed")

    user_system_log.error(e.error)
    if not is_user_exc(e.error.exc_val):
        code = const.EXIT_CODE.EXIT_INTERNAL_ERROR
        system_log.error(_(u"strategy execute exception"), exc=e)
    else:
        code = const.EXIT_CODE.EXIT_USER_ERROR
        user_detail_log.error(_(u"strategy execute exception"), exc=e)

    return code


def enable_profiler(env, scope):
    # decorate line profiler
    import line_profiler
    import inspect
    env.profile_deco = profile_deco = line_profiler.LineProfiler()
    for name in scope:
        obj = scope[name]
        if getattr(obj, "__module__", None) != "rqalpha.user_module":
            continue
        if inspect.isfunction(obj):
            scope[name] = profile_deco(obj)
        if inspect.isclass(obj):
            for key, val in six.iteritems(obj.__dict__):
                if inspect.isfunction(val):
                    setattr(obj, key, profile_deco(val))


def output_profile_result(env):
    stdout_trap = six.StringIO()
    env.profile_deco.print_stats(stdout_trap)
    profile_output = stdout_trap.getvalue()
    profile_output = profile_output.rstrip()
    six.print_(profile_output)
    env.event_bus.publish_event(Event(EVENT.ON_LINE_PROFILER_RESULT, result=profile_output))


def set_loggers(config):
    from rqalpha.utils.logger import user_log, user_system_log, user_detail_log, system_log, basic_system_log, std_log
    from rqalpha.utils.logger import user_std_handler, init_logger
    from rqalpha.utils import logger
    extra_config = config.extra

    init_logger()

    for log in [basic_system_log, system_log, std_log, user_system_log, user_detail_log]:
        log.level = getattr(logbook, config.extra.log_level.upper(), logbook.NOTSET)

    user_log.level = logbook.DEBUG

    if extra_config.log_level.upper() != "NONE":
        if not extra_config.user_log_disabled:
            user_log.handlers.append(user_std_handler)
        if not extra_config.user_system_log_disabled:
            user_system_log.handlers.append(user_std_handler)

    for logger_name, level in extra_config.logger:
        getattr(logger, logger_name).level = getattr(logbook, level.upper())

1	# -- coding: utf-8 --
2	#
3	# Copyright 2017 Ricequant, Inc
4	#
5	# Licensed under the Apache License, Version 2.0 (the "License");
6	# you may not use this file except in compliance with the License.
7	# You may obtain a copy of the License at
8	#
9	# http://www.apache.org/licenses/LICENSE-2.0
10	#
11	# Unless required by applicable law or agreed to in writing, software
12	# distributed under the License is distributed on an "AS IS" BASIS,
13	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	# See the License for the specific language governing permissions and
15	# limitations under the License.
16
17	import os	4✔
18	import sys	4✔
19	import tarfile	4✔
20	import tempfile	4✔
21	import datetime	4✔
22	import shutil	4✔
23	from pprint import pformat	4✔
24
25	import logbook	4✔
26	import click	4✔
27	import jsonpickle.ext.numpy as jsonpickle_numpy	4✔
28	import pytz	4✔
29	import requests	4✔
30	import six	4✔
31
32	from rqalpha import const	4✔
33	from rqalpha.api import helper as api_helper	4✔
34	from rqalpha.core.strategy_loader import FileStrategyLoader, SourceCodeStrategyLoader, UserFuncStrategyLoader	4✔
35	from rqalpha.core.strategy import Strategy	4✔
36	from rqalpha.core.strategy_universe import StrategyUniverse	4✔
37	from rqalpha.core.global_var import GlobalVars	4✔
38	from rqalpha.core.strategy_context import StrategyContext	4✔
39	from rqalpha.data.base_data_source import BaseDataSource	4✔
40	from rqalpha.data.data_proxy import DataProxy	4✔
41	from rqalpha.environment import Environment	4✔
42	from rqalpha.events import EVENT, Event	4✔
43	from rqalpha.execution_context import ExecutionContext	4✔
44	from rqalpha.interface import Persistable	4✔
45	from rqalpha.mod import ModHandler	4✔
46	from rqalpha.model.bar import BarMap	4✔
47	from rqalpha.model.portfolio import Portfolio	4✔
48	from rqalpha.model.base_position import Positions	4✔
49	from rqalpha.utils import create_custom_exception, run_with_user_log_disabled, scheduler as mod_scheduler	4✔
50	from rqalpha.utils.exception import CustomException, is_user_exc, patch_user_exc	4✔
51	from rqalpha.utils.i18n import gettext as _	4✔
52	from rqalpha.utils.persisit_helper import CoreObjectsPersistProxy, PersistHelper	4✔
53	from rqalpha.utils.scheduler import Scheduler	4✔
54	from rqalpha.utils.config import set_locale	4✔
55	from rqalpha.utils.logger import system_log, basic_system_log, user_system_log, user_detail_log	4✔
56
57
58	jsonpickle_numpy.register_handlers()	4✔
59
60
61	def _adjust_start_date(config, data_proxy):	4✔
62	origin_start_date, origin_end_date = config.base.start_date, config.base.end_date	4✔
63	start, end = data_proxy.available_data_range(config.base.frequency)	4✔
64
65	config.base.start_date = max(start, config.base.start_date)	4✔
66	config.base.end_date = min(end, config.base.end_date)	4✔
67	config.base.trading_calendar = data_proxy.get_trading_dates(config.base.start_date, config.base.end_date)	4✔
68	if len(config.base.trading_calendar) == 0:	4✔
69	raise patch_user_exc(	×
70	ValueError(
71	_(u"There is no data between {start_date} and {end_date}. Please check your"
72	u" data bundle or select other backtest period.").format(
73	start_date=origin_start_date, end_date=origin_end_date)))
74	config.base.start_date = config.base.trading_calendar[0].date()	4✔
75	config.base.end_date = config.base.trading_calendar[-1].date()	4✔
76	config.base.timezone = pytz.utc	4✔
77
78
79	def _validate_benchmark(config, data_proxy):	4✔
80	benchmark = config.base.benchmark	4✔
81	if benchmark is None:	4✔
82	return	4✔
83	instrument = data_proxy.instruments(benchmark)	4✔
84	if instrument is None:	4✔
85	raise patch_user_exc(ValueError(_(u"invalid benchmark {}").format(benchmark)))	×
86
87	if instrument.order_book_id == "000300.XSHG":	4✔
88	# 000300.XSHG 数据进行了补齐，因此认为只要benchmark设置了000300.XSHG，就存在数据，不受限于上市日期。
89	return	4✔
90	config = Environment.get_instance().config	4✔
91	start_date = config.base.start_date	4✔
92	end_date = config.base.end_date	4✔
93	if instrument.listed_date.date() > start_date:	4✔
94	raise patch_user_exc(ValueError(	×
95	_(u"benchmark {benchmark} has not been listed on {start_date}").format(benchmark=benchmark,
96	start_date=start_date)))
97	if instrument.de_listed_date.date() < end_date:	4✔
98	raise patch_user_exc(ValueError(	×
99	_(u"benchmark {benchmark} has been de_listed on {end_date}").format(benchmark=benchmark,
100	end_date=end_date)))
101
102
103	def create_benchmark_portfolio(env):	4✔
104	if env.config.base.benchmark is None:	4✔
105	return None	4✔
106
107	BenchmarkAccount = env.get_account_model(const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name)	4✔
108	BenchmarkPosition = env.get_position_model(const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name)	4✔
109
110	start_date = env.config.base.start_date	4✔
111	total_cash = sum(env.config.base.accounts.values())	4✔
112	accounts = {	4✔
113	const.DEFAULT_ACCOUNT_TYPE.BENCHMARK.name: BenchmarkAccount(total_cash, Positions(BenchmarkPosition))
114	}
115	return Portfolio(start_date, 1, total_cash, accounts)	4✔
116
117
118	def create_base_scope():	4✔
119	import copy	4✔
120	from rqalpha.utils.logger import user_print, user_log	4✔
121
122	from . import user_module	4✔
123	scope = copy.copy(user_module.__dict__)	4✔
124	scope.update({	4✔
125	"logger": user_log,
126	"print": user_print,
127	})
128
129	return scope	4✔
130
131
132	def update_bundle(data_bundle_path=None, locale="zh_Hans_CN", confirm=True):	4✔
133	set_locale(locale)	×
134	default_bundle_path = os.path.abspath(os.path.expanduser('~/.rqalpha/bundle'))	×
135	if data_bundle_path is None:	×
136	data_bundle_path = default_bundle_path	×
137	else:
138	data_bundle_path = os.path.abspath(os.path.join(data_bundle_path, './bundle/'))	×
139	if (confirm and os.path.exists(data_bundle_path) and data_bundle_path != default_bundle_path and	×
140	os.listdir(data_bundle_path)):
141	click.confirm(_(u"""	×
142	[WARNING]
143	Target bundle path {data_bundle_path} is not empty.
144	The content of this folder will be REMOVED before updating.
145	Are you sure to continue?""").format(data_bundle_path=data_bundle_path), abort=True)
146
147	day = datetime.date.today()	×
148	tmp = os.path.join(tempfile.gettempdir(), 'rq.bundle')	×
149
150	while True:	×
151	url = 'http://7xjci3.com1.z0.glb.clouddn.com/bundles_v3/rqbundle_%04d%02d%02d.tar.bz2' % (	×
152	day.year, day.month, day.day)
153	six.print_(_(u"try {} ...").format(url))	×
154	r = requests.get(url, stream=True)	×
155	if r.status_code != 200:	×
156	day = day - datetime.timedelta(days=1)	×
157	continue	×
158
159	out = open(tmp, 'wb')	×
160	total_length = int(r.headers.get('content-length'))	×
161
162	with click.progressbar(length=total_length, label=_(u"downloading ...")) as bar:	×
163	for data in r.iter_content(chunk_size=8192):	×
164	bar.update(len(data))	×
165	out.write(data)	×
166
167	out.close()	×
168	break	×
169
170	shutil.rmtree(data_bundle_path, ignore_errors=True)	×
171	os.makedirs(data_bundle_path)	×
172	tar = tarfile.open(tmp, 'r:bz2')	×
173	tar.extractall(data_bundle_path)	×
174	tar.close()	×
175	os.remove(tmp)	×
176	six.print_(_(u"Data bundle download successfully in {bundle_path}").format(bundle_path=data_bundle_path))	×
177
178
179	def run(config, source_code=None, user_funcs=None):	4✔
180	env = Environment(config)	4✔
181	persist_helper = None	4✔
182	init_succeed = False	4✔
183	mod_handler = ModHandler()	4✔
184
185	try:	4✔
186	# avoid register handlers everytime
187	# when running in ipython
188	set_loggers(config)	4✔
189	basic_system_log.debug("\n" + pformat(config.convert_to_dict()))	4✔
190
191	if source_code is not None:	4✔
192	env.set_strategy_loader(SourceCodeStrategyLoader(source_code))	4✔
193	elif user_funcs is not None:	4✔
194	env.set_strategy_loader(UserFuncStrategyLoader(user_funcs))	×
195	else:
196	env.set_strategy_loader(FileStrategyLoader(config.base.strategy_file))	4✔
197	env.set_global_vars(GlobalVars())	4✔
198	mod_handler.set_env(env)	4✔
199	mod_handler.start_up()	4✔
200
201	if not env.data_source:	4✔
202	env.set_data_source(BaseDataSource(config.base.data_bundle_path))	4✔
203	env.set_data_proxy(DataProxy(env.data_source))	4✔
204
205	Scheduler.set_trading_dates_(env.data_source.get_trading_calendar())	4✔
206	scheduler = Scheduler(config.base.frequency)	4✔
207	mod_scheduler._scheduler = scheduler	4✔
208
209	env._universe = StrategyUniverse()	4✔
210
211	_adjust_start_date(env.config, env.data_proxy)	4✔
212
213	_validate_benchmark(env.config, env.data_proxy)	4✔
214
215	# FIXME
216	start_dt = datetime.datetime.combine(config.base.start_date, datetime.datetime.min.time())	4✔
217	env.calendar_dt = start_dt	4✔
218	env.trading_dt = start_dt	4✔
219
220	broker = env.broker	4✔
221	assert broker is not None	4✔
222	env.portfolio = broker.get_portfolio()	4✔
223	env.benchmark_portfolio = create_benchmark_portfolio(env)	4✔
224
225	event_source = env.event_source	4✔
226	assert event_source is not None	4✔
227
228	bar_dict = BarMap(env.data_proxy, config.base.frequency)	4✔
229	env.set_bar_dict(bar_dict)	4✔
230
231	if env.price_board is None:	4✔
232	from .core.bar_dict_price_board import BarDictPriceBoard	4✔
233	env.price_board = BarDictPriceBoard()	4✔
234
235	ctx = ExecutionContext(const.EXECUTION_PHASE.GLOBAL)	4✔
236	ctx._push()	4✔
237
238	env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_INIT))	4✔
239
240	scope = create_base_scope()	4✔
241	scope.update({	4✔
242	"g": env.global_vars
243	})
244
245	apis = api_helper.get_apis()	4✔
246	scope.update(apis)	4✔
247
248	scope = env.strategy_loader.load(scope)	4✔
249
250	if env.config.extra.enable_profiler:	4✔
251	enable_profiler(env, scope)	×
252
253	ucontext = StrategyContext()	4✔
254	user_strategy = Strategy(env.event_bus, scope, ucontext)	4✔
255	scheduler.set_user_context(ucontext)	4✔
256
257	if not config.extra.force_run_init_when_pt_resume:	4✔
258	with run_with_user_log_disabled(disabled=config.base.resume_mode):	4✔
259	user_strategy.init()	4✔
260
261	if config.extra.context_vars:	4✔
262	for k, v in six.iteritems(config.extra.context_vars):	×
263	setattr(ucontext, k, v)	×
264
265	if config.base.persist:	4✔
266	persist_provider = env.persist_provider	×
267	if persist_provider is None:	×
268	raise RuntimeError(_(u"Missing persist provider. You need to set persist_provider before use persist"))	×
269	persist_helper = PersistHelper(persist_provider, env.event_bus, config.base.persist_mode)	×
270	env.set_persist_helper(persist_helper)	×
271	persist_helper.register('core', CoreObjectsPersistProxy(scheduler))	×
272	persist_helper.register('user_context', ucontext)	×
273	persist_helper.register('global_vars', env.global_vars)	×
274	persist_helper.register('universe', env._universe)	×
275	if isinstance(event_source, Persistable):	×
276	persist_helper.register('event_source', event_source)	×
277	persist_helper.register('portfolio', env.portfolio)	×
278	if env.benchmark_portfolio:	×
279	persist_helper.register('benchmark_portfolio', env.benchmark_portfolio)	×
280	for name, module in six.iteritems(env.mod_dict):	×
281	if isinstance(module, Persistable):	×
282	persist_helper.register('mod_{}'.format(name), module)	×
283	# broker will restore open orders from account
284	if isinstance(broker, Persistable):	×
285	persist_helper.register('broker', broker)	×
286
287	env.event_bus.publish_event(Event(EVENT.BEFORE_SYSTEM_RESTORED))	×
288	persist_helper.restore()	×
289	env.event_bus.publish_event(Event(EVENT.POST_SYSTEM_RESTORED))	×
290
291	init_succeed = True	4✔
292
293	# When force_run_init_when_pt_resume is active,
294	# we should run `init` after restore persist data
295	if config.extra.force_run_init_when_pt_resume:	4✔
296	assert config.base.resume_mode == True	×
297	with run_with_user_log_disabled(disabled=False):	×
298	env._universe._set = set()	×
299	user_strategy.init()	×
300
301	from .core.executor import Executor	4✔
302	Executor(env).run(bar_dict)	4✔
303
304	if env.profile_deco:	4✔
305	output_profile_result(env)	×
306	except CustomException as e:	×
307	if init_succeed and env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:	×
308	persist_helper.persist()	×
309
310	code = _exception_handler(e)	×
311	mod_handler.tear_down(code, e)	×
312	except Exception as e:	×
313	if init_succeed and env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_CRASH:	×
314	persist_helper.persist()	×
315
316	exc_type, exc_val, exc_tb = sys.exc_info()	×
317	user_exc = create_custom_exception(exc_type, exc_val, exc_tb, config.base.strategy_file)	×
318
319	code = _exception_handler(user_exc)	×
320	mod_handler.tear_down(code, user_exc)	×
321	else:
322	if (env.config.base.persist and persist_helper and env.config.base.persist_mode == const.PERSIST_MODE.ON_NORMAL_EXIT):	4✔
323	persist_helper.persist()	×
324	result = mod_handler.tear_down(const.EXIT_CODE.EXIT_SUCCESS)	4✔
325	system_log.debug(_(u"strategy run successfully, normal exit"))	4✔
326	return result	4✔
327
328
329	def _exception_handler(e):	4✔
330	try:	×
331	sys.excepthook(e.error.exc_type, e.error.exc_val, e.error.exc_tb)	×
332	except Exception as e:	×
333	system_log.exception("hook exception failed")	×
334
335	user_system_log.error(e.error)	×
336	if not is_user_exc(e.error.exc_val):	×
337	code = const.EXIT_CODE.EXIT_INTERNAL_ERROR	×
338	system_log.error(_(u"strategy execute exception"), exc=e)	×
339	else:
340	code = const.EXIT_CODE.EXIT_USER_ERROR	×
341	user_detail_log.error(_(u"strategy execute exception"), exc=e)	×
342
343	return code	×
344
345
346	def enable_profiler(env, scope):	4✔
347	# decorate line profiler
348	import line_profiler	×
349	import inspect	×
350	env.profile_deco = profile_deco = line_profiler.LineProfiler()	×
351	for name in scope:	×
352	obj = scope[name]	×
353	if getattr(obj, "__module__", None) != "rqalpha.user_module":	×
354	continue	×
355	if inspect.isfunction(obj):	×
356	scope[name] = profile_deco(obj)	×
357	if inspect.isclass(obj):	×
358	for key, val in six.iteritems(obj.__dict__):	×
359	if inspect.isfunction(val):	×
360	setattr(obj, key, profile_deco(val))	×
361
362
363	def output_profile_result(env):	4✔
364	stdout_trap = six.StringIO()	×
365	env.profile_deco.print_stats(stdout_trap)	×
366	profile_output = stdout_trap.getvalue()	×
367	profile_output = profile_output.rstrip()	×
368	six.print_(profile_output)	×
369	env.event_bus.publish_event(Event(EVENT.ON_LINE_PROFILER_RESULT, result=profile_output))	×
370
371
372	def set_loggers(config):	4✔
373	from rqalpha.utils.logger import user_log, user_system_log, user_detail_log, system_log, basic_system_log, std_log	4✔
374	from rqalpha.utils.logger import user_std_handler, init_logger	4✔
375	from rqalpha.utils import logger	4✔
376	extra_config = config.extra	4✔
377
378	init_logger()	4✔
379
380	for log in [basic_system_log, system_log, std_log, user_system_log, user_detail_log]:	4✔
381	log.level = getattr(logbook, config.extra.log_level.upper(), logbook.NOTSET)	4✔
382
383	user_log.level = logbook.DEBUG	4✔
384
385	if extra_config.log_level.upper() != "NONE":	4✔
386	if not extra_config.user_log_disabled:	4✔
387	user_log.handlers.append(user_std_handler)	4✔
388	if not extra_config.user_system_log_disabled:	4✔
389	user_system_log.handlers.append(user_std_handler)	4✔
390
391	for logger_name, level in extra_config.logger:	4✔
392	getattr(logger, logger_name).level = getattr(logbook, level.upper())	×

ricequant / rqalpha / 1038

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous