origin_start_date, origin_end_date = config.base.start_date, config.base.end_date

start, end = data_proxy.available_data_range(config.base.frequency)

# print(repr(start), repr(end))

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 trading day between {start_date} and {end_date}.").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()

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,

if env.config.base.benchmark is None:

return None

from const import ACCOUNT_TYPE

from model.account import BenchmarkAccount

from model.position import Positions, StockPosition

from model.portfolio import Portfolio

accounts = {}

config = env.config

start_date = config.base.start_date

total_cash = 0

for account_type in config.base.account_list:

if account_type == ACCOUNT_TYPE.STOCK:

total_cash += config.base.stock_starting_cash

elif account_type == ACCOUNT_TYPE.FUTURE:

total_cash += config.base.future_starting_cash

else:

raise NotImplementedError

accounts[ACCOUNT_TYPE.BENCHMARK] = BenchmarkAccount(total_cash, Positions(StockPosition))

import copy

import user_module

scope = copy.copy(user_module.__dict__)

scope.update({

"logger": user_log,

"print": user_print,

})

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"""

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)

# url = 'http://7xjci3.com1.z0.glb.clouddn.com/bundles_v3/rqbundle_%04d%02d%02d.tar.bz2' % (

# 2017, 3, 2)

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)

env = Environment(config)

persist_helper = None

init_succeed = False

mod_handler = ModHandler()

try:

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)

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()

# FIXME

start_dt = datetime.datetime.combine(config.base.start_date, datetime.datetime.min.time())

env.calendar_dt = start_dt

env.trading_dt = start_dt

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(config.base.account_list)

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

persist_helper = PersistHelper(persist_provider, env.event_bus, config.base.persist_mode)

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)

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):

user_strategy.init()

from core.executor import Executor

Executor(env).run(bar_dict)

# print(env.__dict__)

if env.profile_deco:

output_profile_result(env)

result = mod_handler.tear_down(const.EXIT_CODE.EXIT_SUCCESS)

system_log.debug(_(u"strategy run successfully, normal exit"))

return result

except CustomException as e:

if init_succeed and env.config.base.persist and persist_helper:

persist_helper.persist()

user_detail_log.exception(_(u"strategy execute exception"))

user_system_log.error(e.error)

better_exceptions.excepthook(e.error.exc_type, e.error.exc_val, e.error.exc_tb)

mod_handler.tear_down(const.EXIT_CODE.EXIT_USER_ERROR, e)

except Exception as e:

if init_succeed and env.config.base.persist and persist_helper:

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)

better_exceptions.excepthook(exc_type, exc_val, exc_tb)

user_system_log.error(user_exc.error)

code = const.EXIT_CODE.EXIT_USER_ERROR

if not is_user_exc(exc_val):

system_log.exception(_(u"strategy execute exception"))

code = const.EXIT_CODE.EXIT_INTERNAL_ERROR

else:

user_detail_log.exception(_(u"strategy execute exception"))

# 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):

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)