Parallel request historical options chain prices / Last known price in IBrokers (R)

Question

I am trying to create Current Options Chain (options per strike, per expiration) for a ticker.

library(IBrokers)    
tws <- twsConnect()
# Lets say only Call prices
AA <- reqContractDetails(tws, twsOption(local="", right="C", symbol="AAPL"))

Native implementation with snapshot is too slow:

reqMktData(tws, AA[1:2], snapshot = TRUE)

It waits around 11 sec per contract (Current number of Contracts is 626)

---

Another implementation:

snapShot <- function (twsCon, eWrapper, timestamp, file, playback = 1, ...)
{
  if (missing(eWrapper))
    eWrapper <- eWrapper()
  names(eWrapper$.Data$data) <- eWrapper$.Data$symbols
  con <- twsCon[[1]]
  if (inherits(twsCon, "twsPlayback")) {
    sys.time <- NULL
    while (TRUE) {
      if (!is.null(timestamp)) {
        last.time <- sys.time
        sys.time <- as.POSIXct(strptime(paste(readBin(con,
                                                      character(), 2), collapse = " "), timestamp))
        if (!is.null(last.time)) {
          Sys.sleep((sys.time - last.time) * playback)
        }
        curMsg <- .Internal(readBin(con, "character",
                                    1L, NA_integer_, TRUE, FALSE))
        if (length(curMsg) < 1)
          next
        processMsg(curMsg, con, eWrapper, format(sys.time,
                                                 timestamp), file, ...)
      }
      else {
        curMsg <- readBin(con, character(), 1)
        if (length(curMsg) < 1)
          next
        processMsg(curMsg, con, eWrapper, timestamp,
                   file, ...)
        if (curMsg == .twsIncomingMSG$REAL_TIME_BARS)
          Sys.sleep(5 * playback)
      }
    }
  }
  else {
    evalWithTimeout(
    while (TRUE) {
      socketSelect(list(con), FALSE, NULL)
      curMsg <- .Internal(readBin(con, "character", 1L,
                                  NA_integer_, TRUE, FALSE))
      if (!is.null(timestamp)) {
        processMsg(curMsg, con, eWrapper, format(Sys.time(),
                                                 timestamp), file, ...)
      }
      else {
        processMsg(curMsg, con, eWrapper, timestamp,
                   file, ...)
      }
      if (!any(sapply(eWrapper$.Data$data, is.na)))
        return(do.call(rbind, lapply(eWrapper$.Data$data,
                                     as.data.frame)))
    }, timeout=5, onTimeout="warning")
  }
} 

reqMktData(tws, AA[1:20], eventWrapper=eWrapper.data(20),CALLBACK=snapShot)

It avoids waiting ( 11 secs ).

But this doesn't work if there is no real-time data or markets are closed.

So, I want to get only the last known price even if markets are closed.
This is my pseudo-solution:

reqHistoricalData(tws, AA[[1]]$contract, whatToShow='BID', barSize = "1 min", duration = "60 S")

Is there a way to parallelize this solution so it will call for historical price of several contract?

Currently it spends around 2.3 seconds per contract, while previous solution is able to get 20-30 contracts with the same time spent.

Answer 1

Instead of using reqMktData(), consider using reqRealTimeBars() with a variable containing your list of contracts to do what you want without the limitations of reqHistoricalData().

Real Time Bars is a query for streaming Historical Data, the data is relayed back from the same servers that provide Historical Data.