Построение системы

                     PRICE    CARRY

2015-04-21 23:00:00 97.9050 97.985

2015-04-22 12:00:06 97.9175 NaN

2015-04-22 13:00:33 97.9025 NaN

2015-04-22 14:00:59 97.9075 NaN

2015-04-22 15:01:20 97.8675 NaN

2015-04-22 16:07:57 97.8475 NaN

2015-04-22 17:08:22 97.8425 NaN

2015-04-22 18:08:43 97.8275 NaN

2015-04-22 19:09:02 97.8325 NaN

2015-04-22 23:00:00 97.8250 97.905

2015-04-23 12:15:44 97.8575 NaN

…. snip ….

2015-04-23 19:43:42 97.8825 NaN

2015-04-23 23:00:00 97.8750 97.955

2015-04-24 12:14:24 97.8675 NaN

… snip …..

2015-04-24 19:42:22 97.9025 NaN

2015-04-24 23:00:00 97.9250 98.005

2015-04-27 12:00:05 97.9125 NaN 

while okay_to_run:

    ## Большая петля собирания цен

    ## Is it after 8pm, or whenever we stop? Then autostop

     if now()>last_sample_at:

         log.info("Нормальная остановка процесса при закрытии рынков")

         okay_to_run=False

         break

     for code in all_codes:

         market_closed=check_market_is_closed(code)

         if market_closed:

             ## не записывать, если рынок закрыт

             continue  

         if check_process(dbtype, "SAMPLING", code)=="STOP":

         ## предотвращение запуска процесса

            continue


         last_run=get_last_run(code)

         if last_run is not None:

            if (now() - last_run).total_seconds()<(60*60):

                #При новом запуске запрашиваем часовые цены

                continue


         raw_sample_instrument(code)

         ## Сшивание цен. Возвращает число новых добавленных точек

         new_prices_added=sample_adj_instrument(code)

         if new_prices_added>0:

           ## Получили данные - запускаем код получения сигналов

               signals_runner(code)

      ## end of for loop

    ##

    ##Окончание цикла while

def raw_sample_instrument(code, entrymode=”AUTO”):

    ## Если мы запускаем вручную, то указываем entrymode=”MANUAL”

    ## Получаем начало данных книги заявок - см. следующую функцию  

    bookdata=get_market_data(code, snapshot=True)


    mid_price_value=midprice(bookdata)


    if isnan(mid_price_value):

       log.warning("Не найдены новые или доступные цены")

    else:

        ## Используем местное время для таймстампа

        sampletime=now()

        pricing_data=TimeSeries([mid_price_value], index=[sampletime])

        resolve_and_add_pricing_data(code, pricing_data, entrymode)

        size=inside_size(bookdata)

        spread=inside_spread(bookdata)

def get_market_data(code, snapshot=True, maxstaleseconds=60, maxwaitseconds=30):

"""

Возвращает рыночные данные с максимальной задержкой, если snapshot=False 
Если в течение maxwait получены не все поля, возвращает NaN
Алгоритм пользователя
- Это получение выборки цен. Нужен последний тик ( с определенной задержкой)
(Проверка последнего тика. Если его нет, стартует запись, пока не будет доступен полный список. Потом возвращает его, если ничего не записалось, возвращает NaN)
[также используется для диагностики цен, например при роллировании]
- Проверка ликвидности . Получение последних рыночных данных и принятие решения о продолжении записи

"""

    global mymarketdata

    ## Получение рыночных данных

   if mymarketdata is None:

      mymarketdata=simple_market_data()

      ## Запрос и получение данных

      stored_data=mymarketdata.get_contract( code, maxdelay=maxstaleseconds)

      if _no_nans(stored_data):

      ## Мы используем данные, если не встречается NaN

         useable_prices=True

      else:

         useable_prices=False


    if not snapshot or not useable_prices:

         ## Нужно запустить сервер тиков

         ## Это создает идентификационный номер, если нужно

         start_ticker_for_contract(dbtype, tws, contract)

         started_tick_server=True

    else:

         started_tick_server=False

    start_time=datetime.datetime.now()


    ## Этот цикл останавливается, если нет приемлемых цен

   timespent=0

      while not useable_prices and timespent < maxwaitseconds: stored_data=mymarketdata.get_contract(code, maxstaleseconds)

        useable_prices=_no_nans(stored_data)

        timespent=(now() - start_time).total_seconds()

     if started_tick_server and snapshot:

        ## need to stop the server because we are taking a snapshot

        ## don't want to continue ticking, reduce the number of prices we're getting

        ## note ticks may still arrive...

        ## note the tickid will still live on!

        ## note we won't turn off if active order

      stop_ticker_for_contract(code)


    return stored_data


def resolve_and_add_pricing_data(code, pricing_data, entrymode):


    MIN_OBSERVATIONS=10

   current_price_matrix=read_prices_for_contract(code)


   if current_price_matrix.shape[0] > MIN_OBSERVATIONS:

      ## resolve the mode, returns None if AUTO and prices fail checks

      pricing_data=resolveprice(current_price_matrix, pricing_data, entrymode)

   else:

      ## just leave prices as they are

      log.warning("No existing prices can't do any checks")


      add_price_matrix(code, pricing_data)

   return pricing_data)


def resolveprice(current_price_matrix, pricing_data, entrymode):

"""

Function that resolves prices depending on entrymode AUTO or MANUAL


Returns new pricing_data - if this is None then we don't have any valid prices (happens only in AUTO mode)

"""



   assert entrymode in ["AUTO", "MANUAL"]


   spike=checkspike(current_price_matrix, pricing_data)

   if spike:

      """

      Potentially bad price


      If running in manual mode then allow user to override, else flag

      """

      if entrymode=="MANUAL":


         ## Allows you to manually check prices, and weed out anything thats bad

         pricing_data=manual_pricing_data(current_price_matrix, pricing_data, describe)


      elif entrymode=="AUTO":

         ## no user interaction possible

         log.critical("Sample failed spike check price move")

         pricing_data=None

   return pricing_data