_PyContextInfo.py

#coding:utf-8
from functools import wraps
import copy
import traceback
import time

hint_get_history_data = True
hint_get_market_data = True
hint_get_local_data = True

class __PyContext(object):
    def __init__(self, contextinfo=None):
        self.context = contextinfo
        self.z8sglma_last_version = None
        self.z8sglma_last_barpos = -1
        self.subMap = {}

    def set_account(self, acct):
        self.context.set_account(acct)

    def set_universe(self, universe):
        last_universe = self.context.get_universe();
        universe = list(set(universe).difference(set(last_universe)));
        self.context.set_universe(universe)

    def get_universe(self):
        return self.context.get_universe()
    
    def is_last_bar(self):
        return self.context.is_last_bar()

    def is_new_bar(self):
        return self.context.is_new_bar()
    
    def get_history_data(self, len, period, field, dividend_type='none', skip_paused=True):
        global hint_get_history_data
        if hint_get_history_data:
            print ("get_history_data接口版本较老，推荐使用get_market_data_ex替代，配合download_history_data补充昨日以前的历史数据")
            hint_get_history_data = False
        return self.context.get_history_data(len, period, field, dividend_type, skip_paused)
    
    def get_industry(self, industry_name, real_timetag = -1):
        return self.context.get_industry(industry_name, real_timetag)

    def get_last_close(self,stock):
        return self.context.get_last_close(stock)

    def get_last_volume(self,stock):
        return self.context.get_last_volume(stock)
    
    def get_sector(self, sectorname, real_timetag = -1):
        return self.context.get_sector(sectorname, real_timetag)

    def get_scale_and_stock(self, total, stockValue, stock):
        return self.context.get_scale_and_stock(total, stockValue, stock)
    def get_scale_and_rank(self,list):
        return self.context.get_scale_and_rank(list)
		
    def get_finance(self, vStock):
        return self.context.get_finance(vStock)
		
    def get_smallcap(self):
        return self.context.get_smallcap()

    def get_midcap(self):
        return self.context.get_midcap()
    
    def get_largecap(self):
        return self.context.get_largecap()
        
    def get_bar_timetag(self, index):
        return self.context.get_bar_timetag(index)

    def get_tick_timetag(self):
        return self.context.get_tick_timetag()

    def get_risk_free_rate(self, index):
        return self.context.get_risk_free_rate(index)

    def get_contract_multiplier(self, stockcode):
        return self.context.get_contract_multiplier(stockcode)
    
    def get_float_caps(self, stockcode):
        return self.context.get_float_caps(stockcode)
    
    def get_total_share(self, stockcode):
        return self.context.get_total_share(stockcode)
    
    def get_stock_type(self, stock):
        return self.context.get_stock_type(stock)

    def get_stock_name(self, stock):
        return self.context.get_stock_name(stock)

    def get_open_date(self, stock):
        return self.context.get_open_date(stock)

    def get_contract_expire_date(self, stock):
        return str(self.context.get_contract_expire_date(stock))

    def get_svol(self, stock):
        return self.context.get_svol(stock)

    def get_bvol(self, stock):
        return self.context.get_bvol(stock)

    def get_net_value(self, barpositon):
        return self.context.get_net_value(barpositon)
    
    def get_back_test_index(self):
        return self.context.get_back_test_index()
    
    def get_turn_over_rate(self, stockcode):
        return self.context.get_turn_over_rate(stockcode) 
    
    def get_weight_in_index(self, mtkindexcode, stockcode):
        return self.context.get_weight_in_index(mtkindexcode, stockcode)
    
    def get_stock_list_in_sector(self, sectorname, real_timetag = -1):
        if isinstance(real_timetag,str):
            real_timetag = int(time.mktime(time.strptime(real_timetag, '%Y%m%d'))*1000)
        if real_timetag == -1:
            return get_stock_list_in_sector(sectorname)
        return self.context.get_stock_list_in_sector(sectorname, real_timetag)
        
    def get_tradedatafromerds(self, accounttype, accountid, startdate, enddate):
        return self.context.get_tradedatafromerds(accounttype ,accountid, startdate, enddate)

    def get_close_price(self, market, stockCode, realTimetag, period=86400000, dividType=0):
        return self.context.get_close_price(market, stockCode, realTimetag, period, dividType)

    def get_market_data_ex(self, fields=[], stock_code=[], period='follow', start_time='', end_time='', count=-1,
                         dividend_type='follow', fill_data=True, subscribe=True):
        ori_data = self.context.get_market_data2(
            fields
            , stock_code, period
            , start_time, end_time, count
            , dividend_type, fill_data
            , subscribe
        )
        
        import pandas as pd
        result = {}
        
        ifield = 'stime'
        fl = fields
        if fl:
            fl2 = fl if ifield in fl else [ifield] + fl
            for s in ori_data:
                sdata = pd.DataFrame(ori_data[s], columns = fl2)
                sdata2 = sdata[fl]
                sdata2.index = sdata[ifield]
                result[s] = sdata2
        else:
            for s in ori_data:
                sdata = pd.DataFrame(ori_data[s])
                if ifield in sdata:
                    sdata.index = sdata[ifield]
                result[s] = sdata
        
        return result

    def get_market_data_ex_ori(self, fields=[], stock_code=[], period='follow', start_time='', end_time='', count=-1,
                         dividend_type='follow', fill_data=True, subscribe=True):
        oriData = self.context.get_market_data2(
            fields
            , stock_code, period
            , start_time, end_time, count
            , dividend_type, fill_data
            , subscribe
        )
        return oriData

    def get_market_data(self, fields, stock_code=[], start_time='', end_time='', skip_paused=True, period='follow',
                        dividend_type='follow', count=-1):
        global hint_get_market_data
        if hint_get_market_data:
            print ("get_market_data接口版本较老，推荐使用get_market_data_ex替代，配合download_history_data补充昨日以前的历史数据")
            hint_get_market_data = False
        oriData = self.context.get_market_data(fields, stock_code, start_time, end_time, skip_paused, period,dividend_type, count)
        resultDict = {}
        for code in oriData:
            for timenode in oriData[code]:
                values=[]
                for field in fields:
                    values.append(oriData[code][timenode][field])
                key=code+timenode
                resultDict[key]=values
        if len(fields)==1 and len(stock_code)<=1 and ((start_time=='' and end_time=='') or start_time==end_time) and count==-1:
            for key in resultDict:
                return resultDict[key][0]
            return -1
        import numpy as np
        import pandas as pd
        if len(stock_code)<=1 and start_time=='' and end_time=='' and count==-1:
            for key in resultDict:
                result=pd.Series(resultDict[key],index=fields)
                return result.sort_index()
        if len(stock_code)>1 and start_time=='' and end_time=='' and count==-1:
            values=[]
            for code in stock_code:
                if code in oriData:
                    if not oriData[code]:
                        values.append([np.nan])
                    for timenode in oriData[code]:
                        key=code+timenode
                        values.append(resultDict[key])
                else:
                    values.append([np.nan])
            result=pd.DataFrame(values,index=stock_code,columns=fields)
            return result.sort_index()
        if len(stock_code)<=1 and ((start_time!='' or end_time!='') or count>=0):
            values=[]
            times=[]
            for code in oriData:
                for timenode in oriData[code]:
                    key=code+timenode
                    times.append(timenode)
                    values.append(resultDict[key])
            result=pd.DataFrame(values,index=times,columns=fields)
            return result.sort_index()
        if len(stock_code)>1 and ((start_time!='' or end_time!='') or count>=0):
            values={}
            for code in stock_code:
                times=[]
                value=[]
                if code in oriData:
                    for timenode in oriData[code]:
                        key=code+timenode
                        times.append(timenode)
                        value.append(resultDict[key])
                values[code]=pd.DataFrame(value,index=times,columns=fields).sort_index()
            result=pd.Panel(values)
            return result
        return

    def get_full_tick(self, stock_code=[]):
        return self.context.get_full_tick(stock_code)
    def get_north_finance_change(self, period):
        return self.context.get_north_finance_change(period)
    def get_hkt_statistics(self, stock_code):
        return self.context.get_hkt_statistics(stock_code)
    def get_hkt_details(self, stock_code):
        return self.context.get_hkt_details(stock_code)
    def load_stk_list(self, dirfile, namefile):
        return self.context.load_stk_list(dirfile, namefile)
    def load_stk_vol_list(self, dirfile, namefile):
        return self.context.load_stk_vol_list(dirfile, namefile)
    def get_longhubang(self, stock_list=[], startTime='', endTime='', count=-1):
        import pandas as pd
        resultDf = pd.DataFrame()
        if isinstance(endTime, int):
            count = endTime
            endTime = startTime
            startTime = '0'
        else:
            count = -1
        resultDict = self.context.get_longhubang(stock_list, startTime, endTime, count)
        fields = ['stockCode', 'stockName', 'date', 'reason', 'close', 'SpreadRate', 'TurnoverVolume',
                  'Turnover_Amount', "buyTraderBooth", "sellTraderBooth"]
        tradeBoothItemFiled = ["traderName", "buyAmount", "buyPercent", "sellAmount", "sellPercent", "totalAmount",
                               "rank", "direction"]
        for stock in resultDict:
            stockDict = resultDict[stock]
            stockDf = pd.DataFrame()
            if len(stockDict.keys()) < 10:
                continue
            buyTradeBoothDict = stockDict[8]
            sellTradeBoothDict = stockDict[9]
            buyTradeBoothPdList = []
            sellTradeBoothPdList = []
            for TradeBoothIDict in buyTradeBoothDict:
                buyTradeBoothPd = pd.DataFrame()
                for tradeBoothKey in TradeBoothIDict.keys():
                    buyTradeBoothPd[tradeBoothItemFiled[tradeBoothKey]] = TradeBoothIDict[tradeBoothKey]
                buyTradeBoothPdList.append(buyTradeBoothPd)
            for TradeBoothIDict in sellTradeBoothDict:
                sellTradeBoothPd = pd.DataFrame()
                for tradeBoothKey in TradeBoothIDict.keys():
                    sellTradeBoothPd[tradeBoothItemFiled[tradeBoothKey]] = TradeBoothIDict[tradeBoothKey]
                sellTradeBoothPdList.append(sellTradeBoothPd)
            for i in range(0, 8):
                stockDf[fields[i]] = stockDict[i]
            stockDf[fields[8]] = buyTradeBoothPdList
            stockDf[fields[9]] = sellTradeBoothPdList
            resultDf = resultDf.append(stockDf)
        return resultDf

    def get_main_contract(self, codemarket):
        return self.context.get_main_contract(codemarket)

    def get_his_contract_list(self, market):
            return get_his_contracts_list(market);

    def get_date_location(self, date):
        return self.context.get_date_location(date)
    
    def get_product_share(self, code, index=-1):
        return self.context.get_product_share(code, index)

    def get_divid_factors(self, marketAndStock, date = ''):
        return self.context.get_divid_factors(marketAndStock,date)

    def get_financial_data(self, fieldList, stockList, startDate, endDate, report_type = 'report_time', pos = -1):
        if(type(report_type) != str):   # default value error , report_type -> pos 
            pos = report_type;
            report_type = 'report_time';
        if(report_type != 'announce_time' and report_type != 'report_time'):
            return;

    def get_raw_financial_data(self, fieldList, stockList, startDate, endDate, report_type='report_time',data_type='dict'):
        if (report_type != 'announce_time' and report_type != 'report_time'):
            return
        import pandas as pd
        from collections import OrderedDict
        pandasData = self.context.get_financial_data(fieldList, stockList, startDate, endDate, report_type, data_type, True)
        return pandasData;

    def get_financial_data(self, fieldList, stockList, startDate, endDate, report_type='report_time', pos=-1):
        if (type(report_type) != str):  # default value error , report_type -> pos
            pos = report_type
            report_type = 'report_time'
        if (report_type != 'announce_time' and report_type != 'report_time'):
            return
        if type(fieldList) == str and type(stockList) == str:
            return self.context.get_financial_data(fieldList, stockList, startDate, endDate, report_type, pos);
        import pandas as pd
        from collections import OrderedDict
        
        pandasData = self.context.get_financial_data(fieldList, stockList, startDate, endDate, report_type,'dict',False)
        if not pandasData:
            return
        fields = pandasData['field']
        stocks = pandasData['stock']
        dates = pandasData['date']
        values = pandasData['value']

        if len(stocks) == 1 and len(dates) == 1:    #series
            series_list = []
            for value in values:
                if not value:
                    return
                for subValue in value:
                    series_list.append(subValue)
            return pd.Series(series_list, index = fields)
        elif len(stocks) == 1 and len(dates) > 1:   #index = dates, col = fields
            dataDict = OrderedDict()
            for n in range(len(values)):
                dataList = []
                if not values[n]:
                    return
                for subValue in values[n]:
                    dataList.append(subValue)
                dataDict[fields[n]] = pd.Series(dataList, index = dates)
            return pd.DataFrame(dataDict)
        elif len(stocks) > 1 and len(dates) == 1:   #index = stocks col = fields
            dataDict = OrderedDict()
            for n in range(len(values)):
                dataList = []
                if not values[n]:
                    return
                for subValue in values[n]:
                    dataList.append(subValue)
                dataDict[fields[n]] = pd.Series(dataList, index = stocks)
            return pd.DataFrame(dataDict)
        else:                                       #item = stocks major = dates minor = fields
            panels = OrderedDict()
            for i in range(len(stocks)):
                dataDict = OrderedDict()
                for j in range(len(values)):
                    dataList = []
                    value = values[j]
                    if not value:
                        return
                    for k in range(i * len(dates), (i + 1) * len(dates)):
                        dataList.append(value[k])
                    dataDict[fields[j]] = pd.Series(dataList, index = dates)
                panels[stocks[i]] = pd.DataFrame(dataDict)
            return pd.Panel(panels)
            
    def get_top10_share_holder(self, stock_list, data_name,start_time,end_time, report_type='report_time'):
        import pandas as pd
        resultPanelDict = {}
        resultDict ={}
        if (report_type != 'announce_time' and report_type != 'report_time'):
            return "input report_type = \'report_time\' or report_type = \'announce_time\'"
        if(data_name == 'flow_holder' or data_name == 'holder'):
            resultDict = get_top10_holder(stock_list, data_name, start_time, end_time, report_type);
        else:
            return "input data_name = \'flow_holder\' or data_name = \'holder\'"
        fields = ["holdName","holderType","holdNum","changReason","holdRatio","stockType","rank","status","changNum","changeRatio"]
        for stock in resultDict:
            stockPdData = pd.DataFrame(columns = fields)
            stockDict = resultDict[stock]
            for timeKey in list(stockDict.keys()):
                timelist = stockDict[timeKey]
                stockPdData.loc[timeKey] =  timelist
            resultPanelDict[stock] = stockPdData
        resultPanel = pd.Panel(resultPanelDict)
        stockNum = len(stock_list)
        timeNum = len(resultPanel.major_axis)
        if(stockNum == 1 and timeNum == 1):
            stock = resultPanel.items[0]
            timetag = resultPanel.major_axis[0]
            df = pd.DataFrame(resultPanel[stock])
            result = pd.Series(df.ix[timetag],index = fields)
            return result
        elif(stockNum > 1 and timeNum == 1):
            timetag = resultPanel.major_axis[0]
            result = pd.DataFrame(resultPanel.major_xs(timetag),index =  fields,columns = resultPanel.items);
            result = result.T
            return  result
        elif(stockNum == 1 and timeNum > 1):
            stock = resultPanel.items[0]
            result = pd.DataFrame(resultPanel[stock])
            return result
        elif(stockNum > 1 and timeNum > 1):
            return resultPanel
        return pd.Panel()
    def get_product_asset_value(self, code, index=-1):
        return self.context.get_product_asset_value(code, index)

    def get_product_init_share(self,code=''):
        return self.context.get_product_init_share(code)

    def create_sector(self, sectorname, stocklist):
        return self.context.create_sector(sectorname, stocklist)    
    def get_holder_num(self, stock_list =[], startTime = '', endTime = '', report_type = 'report_time'):
        fields = ["stockCode","timetag","holdNum","AHoldNum","BHoldNum","HHoldNum","uncirculatedHoldNum","circulatedHoldNum"];
        if (report_type != 'announce_time' and report_type != 'report_time'):
            return "input report_type = \'report_time\' or report_type = \'announce_time\'"
        import pandas as pd
        resultDict = get_holder_number(stock_list, startTime, endTime, report_type)
        result  =  pd.DataFrame()
        for stock in resultDict:
            df = pd.DataFrame(columns = fields)
            for i in  resultDict[stock]:
                df[fields[i]]=resultDict[stock][i]
            result = result.append(df)
        return  result
        
    def paint(self, name, data, index, drawStyle, selectcolor='', limit=''):
        selectcolor_low = selectcolor.lower()
        limit_low = limit.lower()
        if '' != selectcolor and 'noaxis' == limit_low:
            return self.context.paint(name, data, index, drawStyle, selectcolor, 0)
        elif '' != selectcolor and 'nodraw' == limit_low:
            return self.context.paint(name, data, index, 7, selectcolor, 0)
        elif 'noaxis' == selectcolor_low:
            return self.context.paint(name, data, index, drawStyle, '', 0)
        elif 'nodraw' == selectcolor_low:
            return self.context.paint(name, data, index, 7, '', 0)
        else:
            return self.context.paint(name, data, index, drawStyle, selectcolor_low, 1)

    def set_slippage(self, b_flag, slippage='none'):
        if slippage != 'none':
            self.context.set_slippage(b_flag,slippage)
        else:
            self.context.set_slippage(b_flag)#b_flag=slippage
            
    
    def get_slippage(self):
        return self.context.get_slippage()
    
    def get_commission(self):
        return self.context.get_commission()

    def set_commission(self,comtype,com='none'):
        if com != 'none':
           self.context.set_commission(comtype,com)
        else:
           self.context.set_commission(0,comtype)#comtype=commission
    
    def is_suspended_stock(self, stock, type = 0):
        return self.context.is_suspended_stock(stock, type)

    def is_stock(self,stock):
        return self.context.is_stock(stock)

    def is_fund(self,stock):
        return self.context.is_fund(stock)

    def is_future(self,market):
        return self.context.is_future(market)

    def run_time(self, funcname, intervalday, time, exchange = "SH"):
        self.context.run_time(funcname, intervalday, time, exchange)

    def get_function_line(self):
        import sys
        return sys._getframe().f_back.f_lineno
        
    def get_trading_dates(self, stockcode, start_date, end_date, count, period='1d'):
        return self.context.get_trading_dates(stockcode, start_date, end_date, count, period)

    def draw_text(self, condition, position, text, limit=''):
        import sys
        line = sys._getframe().f_back.f_lineno
        if 'noaxis' == limit.lower():
            return self.context.draw_text(condition, position, text, line, 0)
        else:
            return self.context.draw_text(condition, position, text, line, 1)

    def draw_vertline(self, condition, price1, price2, color='', limit=''):
        import sys
        line = sys._getframe().f_back.f_lineno

        if 'noaxis' == limit.lower():
            return self.context.draw_vertline(condition, price1, price2, color, line, 0)
        else:
            return self.context.draw_vertline(condition, price1, price2, color, line, 1)

    def draw_icon(self, condition, position, type, limit=''):
        import sys
        line = sys._getframe().f_back.f_lineno
        if (('noaxis' == limit.lower())):
            return self.context.draw_icon(condition, position, type, line, 0)
        else:
            return self.context.draw_icon(condition, position, type, line, 1)

    def draw_number(self, cond, price, number, precision, limit=''):
        import sys
        line = sys._getframe().f_back.f_lineno
        if (('noaxis' == limit.lower())):
            return self.context.draw_number(cond, price, number, precision, line, 0)
        else:
            return self.context.draw_number(cond, price, number, precision, line, 1)
        
    def get_turnover_rate(self, stock_code=[], start_time='19720101', end_time='22010101'):
        import pandas as pd
        import time
        if(len(start_time) != 8 or len(end_time) != 8):
            print('input date time error!!!')
            return pd.DataFrame()
        data = turnover_rate(stock_code, start_time, end_time)
        frame = pd.DataFrame(data)
        
        return frame;

    def get_local_data(self, stock_code='', start_time='19700101', end_time='22010101', period='follow', divid_type='none', count=-1):
        global hint_get_local_data
        if hint_get_local_data:
            print ("get_local_data接口版本较老，推荐使用get_market_data_ex替代，参数subscribe设置为False，只取本地数据不从服务器订阅数据")
            hint_get_local_data = False
        return self.context.get_local_data(stock_code, start_time, end_time, period, divid_type, count)
        
    def get_ETF_list(self, market, stockcode, typeList = []):
        import pandas as pd
        if(len(market) == 0):
            print('input market error!!!')
            return pd.DataFrame()
        data = get_etf_list(market, stockcode, typeList)
        frame = pd.DataFrame(data)
        
        return data;
        
    def get_option_detail_data(self, stockcode):
        return self.context.get_option_detail_data(stockcode)
        
    def get_instrumentdetail(self, marketCode):
        field_list = [
            'ExchangeID'
            , 'InstrumentID'
            , 'InstrumentName'
            , 'ProductID'
            , 'ProductName'
            , 'CreateDate'
            , 'OpenDate'
            , 'ExpireDate'
            , 'PreClose'
            , 'SettlementPrice'
            , 'UpStopPrice'
            , 'DownStopPrice'
            , 'FloatVolumn'
            , 'TotalVolumn'
            , 'LongMarginRatio'
            , 'ShortMarginRatio'
            , 'PriceTick'
            , 'VolumeMultiple'
            , 'MainContract'
            , 'LastVolume'
            , 'InstrumentStatus'
            , 'IsTrading'
            , 'IsRecent'
            , 'HSGTFlag'
        ]

        inst = self.context.get_instrumentdetail(marketCode)

        ret = {}
        for field in field_list:
            ret[field] = inst.get(field)
        return ret

    
    def get_option_undl(self, opt_code):
        inst = self.context.get_instrumentdetail(opt_code)
        if inst and 'ExtendInfo' in inst:
            ext_info = inst['ExtendInfo']
            undl_code_ref = str(ext_info['OptUndlCode']) + '.' + str(ext_info['OptUndlMarket'])
            if opt_code.find(".IF") != -1:
                if undl_code_ref == "000016.SH" or undl_code_ref == "000300.SH" or undl_code_ref == "000852.SH" or undl_code_ref == "000905.SH":
                    return undl_code_ref
            else:
                return undl_code_ref
        return

    def get_option_undl_data(self, undl_code_ref = ''):
        if undl_code_ref:
            opt_list = []
            if undl_code_ref.endswith('.SH'):
                if undl_code_ref == "000016.SH" or undl_code_ref == "000300.SH" or undl_code_ref == "000852.SH" or undl_code_ref == "000905.SH":
                    opt_list = get_stock_list_in_sector('中金所')
                else:
                    opt_list = self.get_stock_list_in_sector('上证期权')
            if undl_code_ref.endswith('.SZ'):
                opt_list = self.get_stock_list_in_sector('深证期权')
            data = []
            for opt_code in opt_list:
                undl_code = self.get_option_undl(opt_code)
                if undl_code == undl_code_ref:
                    data.append(opt_code)
            return data
        else:
            opt_list = []
            opt_list += self.get_stock_list_in_sector('上证期权')
            opt_list += self.get_stock_list_in_sector('深证期权')
            opt_list += self.get_stock_list_in_sector('中金所')
            result = {}
            for opt_code in opt_list:
                undl_code = self.get_option_undl(opt_code)
                if undl_code:
                    if undl_code in result:
                        result[undl_code].append(opt_code)
                    else:
                        result[undl_code] = [opt_code]
            return result

    def get_option_list(self,object,dedate,opttype = "",isavailavle = False):
        result = [];

        undlMarket = "";
        undlCode = "";
        marketcodeList = object.split('.');
        if(len(marketcodeList) !=2):
            return [];
        undlCode = marketcodeList[0]
        undlMarket = marketcodeList[1];
        market = ""
        if(undlMarket == "SH"):
            if undlCode == "000016" or undlCode == "000300" or undlCode == "000852" or undlCode == "000905":
                market = 'IF'
            else:
                market = "SHO"
        elif(undlMarket == "SZ"):
            market = "SZO";
        if(opttype.upper() == "C"):
            opttype = "CALL"
        elif(opttype.upper() == "P"):
            opttype = "PUT"
        optList = []
        if market == 'SHO':
            optList += get_stock_list_in_sector('上证期权')
            hisList = get_stock_list_in_sector('过期上证期权')
            if len(hisList) <= 0:
                hisList = self.get_his_contract_list(market)
            optList += hisList
        elif market == 'SZO':
            optList += get_stock_list_in_sector('深证期权')
            hisList = get_stock_list_in_sector('过期深证期权')
            if len(hisList) <= 0:
                hisList = self.get_his_contract_list(market)
            optList += hisList
        elif market == 'IF':
            optList += get_stock_list_in_sector('中金所')
            hisList = get_stock_list_in_sector('过期中金所')
            if len(hisList) <= 0:
                hisList = self.get_his_contract_list(market)
            optList += hisList
        for opt in optList:
            if(opt.find(market) < 0):
                continue
            inst = self.context.get_instrumentdetail(opt);
            if('ExtendInfo' not in inst):
                continue;
            if(opttype.upper()  != "" and  opttype.upper() != inst['ExtendInfo']["optType"]):
                continue;
            if( (len(dedate) == 6 and str(inst['ExpireDate']).find(dedate) < 0)  ):
                continue
            if( len(dedate) == 8): #option is trade,guosen demand
                createDate = inst['CreateDate'];
                openDate = inst['OpenDate'];
                if(createDate >= 1):
                    openDate = min(openDate,createDate);
                if(openDate < 20150101 or str(openDate) > dedate):
                    continue
                endDate = inst['ExpireDate'];
                if( isavailavle and  str(endDate) < dedate):
                    continue;
            if(inst['ProductID'].find(undlCode) > 0 or inst['ExtendInfo']['OptUndlCode'] == undlCode):
                result.append(opt);
        return result;


    def bsm_price(self,optType,targetPrice,strikePrice,riskFree,sigma,days,dividend = 0):
        optionType = "";
        if(optType.upper() == "C"):
            optionType = "CALL"
        if(optType.upper() == "P"):
            optionType = "PUT"
        if(type(targetPrice) == list):
            result = [];
            for price in targetPrice:
                bsmPrice= calc_bsm_price(optionType,strikePrice,float(price),riskFree,sigma,days,dividend)
                bsmPrice = round(bsmPrice,4)
                result.append(bsmPrice);
            return result;
        else:
            bsmPrice = calc_bsm_price(optionType,strikePrice,targetPrice,riskFree,sigma,days,dividend)
            result = round(bsmPrice,4)
            return result;

    def bsm_iv(self,optType,targetPrice,strikePrice,optionPrice,riskFree,days,dividend = 0):
        if(optType.upper() == "C"):
            optionType = "CALL"
        if(optType.upper() == "P"):
            optionType = "PUT"
        result = calc_bsm_iv(optionType,strikePrice,targetPrice,optionPrice,riskFree,days,dividend)
        result = round(result,4)
        return result

    def get_his_st_data(self,stockCode):
        #tradeDateList = ContextInfo.get_trading_dates(stockCode,'19900101','20380119',1,'1d')
        import json;
        data = get_st_status(stockCode);
        return data;

    def get_option_iv(self,opt_code):
        return  get_opt_iv(opt_code);

    def get_his_index_data(self,stockCode):
        data = get_history_index_weight(stockCode);
        return data
    @property
    def time_tick_size(self):
        return self.context.time_tick_size
    
    @property
    def current_bar(self):
        return self.context.current_bar
    
    @property
    def barpos(self):
        return self.context.barpos

    @property
    def benchmark(self):
        return self.context.benchmark

    @benchmark.setter
    def benchmark(self, value):
        self.context.benchmark = value
    
    @property
    def period(self):
        return self.context.period
    
    @property
    def capital(self):
        return self.context.capital

    @property
    def dividend_type(self):
        return self.context.dividend_type

    @capital.setter
    def capital(self, value):
        self.context.capital = value
    
    @property
    def refresh_rate(self):
        return self.context.refresh_rate

    @refresh_rate.setter
    def refresh_rate(self, value):
        self.context.refresh_rate = value
        
    @property
    def do_back_test(self):
        return self.context.do_back_test

    @do_back_test.setter
    def do_back_test(self, value):
        self.context.do_back_test = value
        
    @property
    def request_id(self):
        return self.context.request_id

        
    @property
    def stockcode(self):
        return self.context.stockcode
    @property
    def stockcode_in_rzrk(self):
        return self.context.stockcode_in_rzrk
    
    @property
    def market(self):
        return self.context.market
        
    @property
    def in_pythonworker(self):
        return self.context.in_pythonworker

    @property
    def start(self):
        return self.context.start
        
    @start.setter
    def start(self,value):
       self.context.start = value

    @property
    def end(self):
        return self.context.end
        
    @end.setter
    def end(self,value):
       self.context.end = value

    @property
    def data_info_level(self):
        return self.context.data_info_level
        
    @data_info_level.setter
    def data_info_level(self,value):
       self.context.data_info_level = value   

    def __deepcopy__(self, memo):
        #print "type:", type(self)
        new_obj = type(self)()
        # del last version when copy, only the last version is reverved
        # self.z8sglma_last_version = None
        for k, v in list(self.__dict__.items()):
            #print "k: %s v: %s" %(k, v)
            # contextInfo variable is from c++, not copy
            if k == "context":
                setattr(new_obj, k, v)
            elif k == "z8sglma_last_version":
                continue
            else:
                setattr(new_obj, k, copy.deepcopy(v, memo))
        return new_obj
        
    def get_factor_data(self, field_list, stock_list, start_date, end_date):
        import pandas as pd
        from collections import OrderedDict
        stocks = []
        if type(stock_list) == str:
            stocks.append(stock_list)
        else:
            stocks = stock_list
        pandasData = get_factor_datas(field_list, stocks, start_date, end_date)
        if not pandasData:
            return
        fields = pandasData['field']
        dates = pandasData['date']
        values = pandasData['value']
        
        if len(stocks) == 1 and len(dates) == 1:    #series
            series_list = []
            for value in values:
                if not value:
                    return
                for subValue in value:
                    series_list.append(subValue)
            return pd.Series(series_list, index = fields)
        elif len(stocks) == 1 and len(dates) > 1:   #index = dates, col = fields
            dataDict = OrderedDict()
            for n in range(len(values)):
                dataList = []
                if not values[n]:
                    return
                for subValue in values[n]:
                    dataList.append(subValue)
                dataDict[fields[n]] = pd.Series(dataList, index = dates)
            return pd.DataFrame(dataDict)
        elif len(stocks) > 1 and len(dates) == 1:   #index = stocks col = fields
            dataDict = OrderedDict()
            for n in range(len(values)):
                dataList = []
                if not values[n]:
                    return
                for subValue in values[n]:
                    dataList.append(subValue)
                dataDict[fields[n]] = pd.Series(dataList, index = stocks)
            return pd.DataFrame(dataDict)
        else:                                       #Key = stocks value = df(index = dates, col = fields)
            panels = OrderedDict()
            for i in range(len(stocks)):
                dataDict = OrderedDict()
                for j in range(len(values)):
                    dataList = []
                    value = values[j]
                    if not value:
                        return
                    for k in range(i * len(dates), (i + 1) * len(dates)):
                        dataList.append(value[k])
                    dataDict[fields[j]] = pd.Series(dataList, index = dates)
                panels[stocks[i]] = pd.DataFrame(dataDict)
            return panels
    
    def subscribe_quote(self, stock_code, period = 'follow', dividend_type = 'follow', result_type = '', callback = None):
        if callback:
            callback1 = callback
            if result_type.lower() == 'dict':
                def on_quote_wrapper(datas):
                    if datas.get('time', None):
                        callback1({stock_code : {k: v[-1] for k, v in datas.items()}})
                    return
                callback = on_quote_wrapper
            elif result_type.lower() == 'list':
                def on_quote_wrapper(datas):
                    callback1({stock_code : datas})
                    return
                callback = on_quote_wrapper
            else:
                import pandas as pd
                def on_quote_wrapper(datas):
                    datas2 = pd.DataFrame(datas)
                    datas2.index = datas2['stime']
                    callback1({stock_code : datas2})
                    return
                callback = on_quote_wrapper
        subID = self.context.subscribe_quote(stock_code, period, dividend_type, callback)
        if subID > 0:
            subInfo = {}
            subInfo['func'] = 'subscribe_quote'
            subInfo['stock_code'] = stock_code
            subInfo['stockCode'] = stock_code
            subInfo['period'] = period
            subInfo['dividend_type'] = dividend_type
            subInfo['dividendType'] = dividend_type
            self.subMap[subID] = subInfo
        return subID
        
    def subscribe_whole_quote(self, code_list, callback = None):
        if callback:
            callback1 = callback
            def on_quote_wrapper(datas):
                callback1(datas)
                return
            callback = on_quote_wrapper
        subID = self.context.subscribe_whole_quote(code_list, callback)
        if subID > 0:
            subInfo = {}
            subInfo['func'] = 'subscribe_whole_quote'
            subInfo['code_list'] = code_list
            self.subMap[subID] = subInfo
        return subID
        
    def unsubscribe_quote(self, subID):
        self.subMap.pop(subID, {})
        return self.context.unsubscribe_quote(subID)
        
    def get_all_subscription(self):
        return self.subMap

def timetag_to_datetime(timetag, format):
    import time
    timetag = timetag/1000
    time_local = time.localtime(timetag)
    return time.strftime(format,time_local)


def resume_context_info(context_info):
    last_barpos = context_info.z8sglma_last_barpos
    if context_info.barpos == last_barpos:
        for k, v in list(context_info.z8sglma_last_version.__dict__.items()):
            if k == "context":
                continue
            elif k == "z8sglma_last_version":
                continue
            else:
                setattr(context_info, k, copy.deepcopy(v))
    else:
        # print "not repeat, barpos:", args[0].barpos
        # print "curr bar: %i last bar: %i" % (args[0].barpos, context_info.last_barpos)
        context_info.z8sglma_last_barpos = context_info.barpos
        context_info.z8sglma_last_version = copy.deepcopy(context_info)

def request_general_file(strReq, callback):
    def wrapper(result, error_code, error_info):
        callback(result, error_code, error_info)
        return
    request_general_file_c(strReq, wrapper)