Ejemplo n.º 1
0
 public TaskResultData(IBDTaskInstruction Instruction, bool HasData = false, object DataObject = null)
 {
     this.Instruction = Instruction;
     this.HasData     = HasData;
     this.Data        = DataObject;
     this.Metadata    = new Dictionary <string, object>();
 }
        public async System.Threading.Tasks.Task RetrieveEquityData(IBDTaskInstruction optionInstruction)
        {
            if (_equityDataCache.Count == 0)
            {
                if (!await this.LookupDerivative(optionInstruction))
                {
                    //right now, this is fatal
                    throw new Exception("Failed to find derivative!");
                }

                var underlying = (Contract)optionInstruction.metadata[IBDMetadataType.underlying];

                var downloadTask = new DownloadHistoricalData(_TaskHandler);

                var ins = new IBDTaskInstruction()
                {
                    contract = underlying, parameters = optionInstruction.parameters.Clone()
                };                                                                                                                               //clone parameters so we get same settings (barSize etc)
                ins.parameters["StartDate"] = optionInstruction.GetParameter("StartDate").ParseElse(DateTime.Now.AddMonths(-6)).ToString();
                var result = await downloadTask.ExecuteAsync(ins);

                if (!result.HasData)                 //right now this is fatal
                {
                    throw new Exception("No data found for underlying!");
                }

                foreach (var quote in (List <HistoricalDataMessage>)result.Data)
                {
                    var quoteDate = (DateTime)Framework.ParseDateTz(quote.Date);
                    _equityDataCache[quoteDate] = quote;
                }
            }

            optionInstruction.metadata[IBDMetadataType.underlyingData] = _equityDataCache;
        }
Ejemplo n.º 3
0
        public static TaskResultData Failure(IBDTaskInstruction Instruction, string Message = null)
        {
            if (!string.IsNullOrEmpty(Message))
            {
                Framework.LogError("[{0}] Task failed: {1}", Instruction.taskType, Message);
            }

            return(new TaskResultData(Instruction, false));
        }
Ejemplo n.º 4
0
        public async System.Threading.Tasks.Task <DateTime> GetStartDate(IBDTaskInstruction Instruction)
        {
            DateTime startDate = Instruction.GetParameter("StartDate").ParseElse(DateTime.MinValue);

            if (startDate == DateTime.MinValue)
            {
                startDate = await _Controller.HistoricalDataManager.GetEarliestDataTime(Instruction.contract);
            }
            startDate = startDate.StartOfDay();

            return(startDate);
        }
Ejemplo n.º 5
0
        public async void ImportCsvData()
        {
            var controller = new IBController();

            Assert.True(controller.Connect(), "Connection setup failed!");

            var taskHandler = new IBDTaskHandler(controller);

            var instruction = new IBDTaskInstruction("ImportCsv");

            instruction.parameters["FilePathName"] = "/Users/jason/Downloads/cboe";
            taskHandler.AddTask(instruction);

            ElasticsearchStorage es = new ElasticsearchStorage(new DataStorage.Processors.StockOptionQuoteProcessor());

            taskHandler.OnTaskResult += es.ProcessTaskResult;

            await taskHandler.BeginAsync();

            await es.FlushAsync();
        }
Ejemplo n.º 6
0
        public override async System.Threading.Tasks.Task ExecuteMultiAsync(IBDTaskInstruction Instruction, Action <TaskResultData> OnTaskResult)
        {
            List <string> files = new List <string>();

            var filePathName = Instruction.GetParameter("FilePathName");

            if (Directory.Exists(filePathName))
            {
                //is dir
                var tmpFiles = Directory.GetFiles(filePathName);

                foreach (string fileName in tmpFiles)
                {
                    if (fileName.EndsWith("csv", StringComparison.InvariantCulture) ||
                        fileName.EndsWith("zip", StringComparison.InvariantCulture))
                    {
                        files.Add(fileName);
                    }
                }

                files.Sort();
            }
            else if (File.Exists(filePathName))
            {
                //is file
                files.Add(filePathName);
            }
            else
            {
                this.LogWarn("No files found in specified location!");
                return;
            }

            foreach (string file in files)
            {
                await ProcessFileAsync(Instruction, file, OnTaskResult);
            }
        }
Ejemplo n.º 7
0
        public async System.Threading.Tasks.Task <bool> LookupDerivative(IBDTaskInstruction Instruction)
        {
            var selectedContracts = await _Controller.ContractManager.GetContractDetails(Instruction.contract);

            if (selectedContracts.Count < 1)
            {
                return(false);
            }
            //reset to full derivative contract definition
            Instruction.contract = selectedContracts[0].Summary;
            int underlyingConId = selectedContracts[0].UnderConId;
            //lookup underlying
            var underlying = await _Controller.ContractManager.GetContract(underlyingConId, string.Empty);             //TODO: empty exchange may not always work

            if (underlying == null)
            {
                return(false);
            }

            Instruction.metadata[IBDMetadataType.underlying] = underlying;

            return(true);
        }
Ejemplo n.º 8
0
        public async void GenerateOptionHistoricalDataTasks()
        {
            var controller = new IBController();

            Assert.True(controller.Connect(), "Connection setup failed!");

            var taskHandler = new IBDTaskHandler(controller);

            var instruction = new IBDTaskInstruction("BuildOptionDownloadTasks")
            {
                Symbol = "VIX", SecType = "OPT"
            };

            instruction.parameters["filter.expirytype"] = OptionChain.Expiration.Type.any.ToString();
            taskHandler.AddTask(instruction);

            var storage = new JSONFile();

            taskHandler.OnTaskResult += storage.ProcessTaskResult;

            await taskHandler.BeginAsync();

            await storage.FlushAsync();
        }
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction instruction)
        {
            Managers.BarSize barSize = instruction.GetParameter("BarSize").ParseElse(Managers.BarSize.M15);

            var selectedContracts = await _Controller.ContractManager.GetContractDetails(instruction.contract);

            if (selectedContracts.Count < 1)
            {
                return(TaskResultData.Failure(instruction, "No matching contracts found!"));
            }

            DateTime earliestDate = await GetStartDate(instruction);

            TimeSpan duration = DateTime.Now.EndOfDay().AddDays(1) - earliestDate;

            this.Log("Fetching data for {0} starting from {1}", instruction.ConId, earliestDate);

            List <HistoricalDataMessage> bars = new List <HistoricalDataMessage>();

            if (duration.TotalDays > 0)
            {
                int days = (int)duration.TotalDays;

                for (var i = 1; i <= days; i++)
                {
                    //we can safely download up to 30 days at a time
                    int pageSize = (days - i) + 1;
                    if (pageSize > 30)
                    {
                        pageSize = 30;
                    }
                    i += pageSize - 1;

                    var data = await _Controller.HistoricalDataManager.GetHistoricalData(
                        instruction.contract,
                        earliestDate.AddDays(i),
                        barSize,
                        pageSize,
                        Managers.HistoricalDataType.TRADES,
                        true);

                    this.Log("Downloaded {0} bars.", data.Count);

                    bars.AddRange(data);
                }
            }


            return(new TaskResultData(instruction, bars.Count > 0, bars));
        }
Ejemplo n.º 10
0
 public virtual System.Threading.Tasks.Task ExecuteMultiAsync(IBDTaskInstruction Instruction, Action <TaskResultData> OnTaskResult)
 {
     throw new NotImplementedException("Check if IsMulti flag is set according to implemented Execute method!");
 }
Ejemplo n.º 11
0
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction instruction)
        {
            //
            var accSummary = await _Controller.AccountManager.GetAccountSummary();

            accSummary.All((i) =>
            {
                Framework.Log("\n{0}=", i.Tag);
                Framework.DebugPrint(i);
                return(true);
            });

            //
            List <Contract> contracts = await _Controller.ContractManager.GetContracts(Managers.SecurityType.STK, "SPY");

            var contract = contracts.First();

            //
            List <ContractDetails> details = await _Controller.ContractManager.GetContractDetails(contract);

            Framework.Log("CONTRACT INFO");
            details.All((i) =>
            {
                Framework.Log(i.LongName);
                return(true);
            });

            //
            var data = await _Controller.HistoricalDataManager.GetHistoricalData(contract, DateTime.Now, Managers.BarSize.M15);

            data.All((bar) =>
            {
                Framework.Log("{0} close={1}", bar.Date, bar.Close);
                return(true);
            });

            //
            var optionChain = await _Controller.OptionManager.GetOptionChain(contract);

            optionChain.Expirations.All((optionExpiry) =>
            {
                Framework.Log("{0}\t PUTS={1}\t CALLS={2}", optionExpiry.Key.ToShortDateString(), optionExpiry.Value.Puts.Count, optionExpiry.Value.Calls.Count);
                return(true);
            });


            return(new TaskResultData(instruction, true, accSummary));
        }
Ejemplo n.º 12
0
        protected async System.Threading.Tasks.Task ProcessFileAsync(IBDTaskInstruction Instruction, string CurrentFile, Action <TaskResultData> OnTakResult)
        {
            IBApi.Contract underlyingContract = null;
            Dictionary <string, List <CboeCsvRecord> > fileOptionQuotes = new Dictionary <string, List <CboeCsvRecord> >();

            ZipArchive zipFile = null;
            Stream     stream;

            if (CurrentFile.EndsWith("zip", StringComparison.InvariantCulture))
            {
                //TODO: support more than 1 file per archive
                zipFile = ZipFile.OpenRead(CurrentFile);
                stream  = zipFile.Entries[0].Open();
            }
            else
            {
                stream = File.OpenRead(CurrentFile);
            }

            this.Log("Processing {0}...", CurrentFile);

            using (stream)
            {
                StreamReader fileStream = new StreamReader(stream);
                CsvReader    reader     = new CsvReader(fileStream);
                foreach (var record in reader.GetRecords <CboeCsvRecord>())
                {
                    if (underlyingContract == null)
                    {
                        underlyingContract = record.AsUnderlyingContract();
                    }
                    else if (underlyingContract.Symbol != record.AsUnderlyingContract().Symbol)
                    {
                        throw new Exception("Task does not support data with multiple underlying contracts!");
                    }

                    string optionLocalSymbol = record.AsOptionContract().LocalSymbol;
                    if (!fileOptionQuotes.ContainsKey(optionLocalSymbol))
                    {
                        fileOptionQuotes[optionLocalSymbol] = new List <CboeCsvRecord>();
                    }

                    fileOptionQuotes[optionLocalSymbol].Add(record);
                }
            }
            if (zipFile != null)
            {
                zipFile.Dispose();
            }

            //grouped by option symbol/contract
            foreach (var optionQuoteSet in fileOptionQuotes)
            {
                var underlyingQuotes = new Dictionary <DateTime, HistoricalDataMessage>();
                var optionQuotes     = new List <HistoricalDataMessage>();
                foreach (CboeCsvRecord quote in optionQuoteSet.Value)
                {
                    optionQuotes.Add(quote.AsOptionQuote());

                    var underlyingQuote = quote.AsUnderlyingQuote();
                    underlyingQuotes[underlyingQuote.Date.ParseElse <DateTime>(DateTime.Now)] = underlyingQuote;
                }

                var ins = new IBDTaskInstruction()
                {
                    contract = optionQuoteSet.Value[0].AsOptionContract(), parameters = Instruction.parameters.Clone()
                };                                                                                                                                                         //clone parameters so we get same settings (barSize etc)
                ins.metadata[IBDMetadataType.underlying]     = underlyingContract;
                ins.metadata[IBDMetadataType.underlyingData] = underlyingQuotes;

                var taskResult = new TaskResultData(ins, true, optionQuotes);

                //fire event with this task result
                OnTakResult(taskResult);

                //give storage a second to keep up
                await System.Threading.Tasks.Task.Delay(10);
            }
        }
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction instruction)
        {
            //First, make sure we have the underlying symbol's data
            await RetrieveEquityData(instruction);

            //then, follow instruction to download option
            return(await base.ExecuteAsync(instruction));
        }
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction instruction)
        {
            var optionList = await base.ExecuteAsync(instruction);

            if (!optionList.HasData)
            {
                return(TaskResultData.Failure(instruction, "No option contracts!"));
            }

            List <IBDTaskInstruction> instructionSet = new List <IBDTaskInstruction>();

            foreach (var optionContractId in (IEnumerable <int>)optionList.Data)
            {
                instructionSet.Add(new IBDTaskInstruction("DownloadStockAndOptionHistoricalData")
                {
                    ConId = optionContractId
                });
            }

            return(new TaskResultData(instruction, true, instructionSet));
        }
Ejemplo n.º 15
0
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction Instruction)
        {
            List <string> files        = new List <string>();
            string        idField      = Instruction.GetParameter("IDField");
            string        dateField    = Instruction.GetParameter("DateField");
            var           filePathName = Instruction.GetParameter("FilePathName");

            if (Directory.Exists(filePathName))
            {
                //is dir
                var tmpFiles = Directory.GetFiles(filePathName);

                foreach (string fileName in tmpFiles)
                {
                    if (fileName.EndsWith("json", StringComparison.InvariantCulture))
                    {
                        files.Add(fileName);
                    }
                }

                files.Sort();
            }
            else if (File.Exists(filePathName))
            {
                //is file
                files.Add(filePathName);
            }
            else
            {
                return(TaskResultData.Failure(Instruction, "No files found in specified location!"));
            }

            this.Log("Reading {0} using id={1} and date={2}...", filePathName, idField, dateField);

            List <IDataRow> allRows = new List <IDataRow>();

            //var results = System.Threading.Tasks.Task.TaskResultData();
            foreach (string file in files)
            {
                allRows.AddRange(ProcessFile(file, idField, dateField));
                await System.Threading.Tasks.Task.Delay(1);
            }

            return(new TaskResultData(Instruction, true, allRows));
        }
        public override async System.Threading.Tasks.Task <TaskResultData> ExecuteAsync(IBDTaskInstruction instruction)
        {
            double limitStrikeHigh = double.MaxValue;
            double limitStrikeLow  = double.MinValue;

            if (instruction.GetParameter("filter.range").ParseElse <double>(0) > 0)
            {
                //get the high-low during the past 6mos so we can filter down the option chain
                var highLow = await _Controller.HistoricalDataManager.GetPriceRange(instruction.contract, 6);

                double rangeDev = (highLow.Item1 - highLow.Item2) * instruction.GetParameter("filter.range").ParseElse <double>(0.3);                //  +/- 30%
                limitStrikeHigh = highLow.Item1 + rangeDev;
                limitStrikeLow  = highLow.Item2 - rangeDev;
                this.Log("Filtering to strikes between {0} and {1}", limitStrikeLow, limitStrikeHigh);
            }

            OptionChain.Expiration.Type expType = instruction.GetParameter("filter.expirytype").ParseElse(OptionChain.Expiration.Type.monthly);
            if (expType != OptionChain.Expiration.Type.any)
            {
                this.Log("Filtering to {0}s", expType);
            }

            int limitExpiries = instruction.GetParameter("filter.expiries").ParseElse(3);

            if (limitExpiries > 0)
            {
                this.Log("Filtering to {0} expiries ahead", limitExpiries);
            }

            var optionChain = await _Controller.OptionManager.GetOptionChain(instruction.contract);

            int        expiryCounter      = 0;
            List <int> flatContractIdList = new List <int>();

            optionChain.Expirations.All((expiration) =>
            {
                if (limitExpiries > 0 && expiryCounter > limitExpiries)
                {
                    return(true);
                }

                if (expType != OptionChain.Expiration.Type.any &&
                    expiration.Value.ExpType != expType)
                {
                    return(true);
                }

                expiryCounter++;

                expiration.Value.Puts.All((contract) =>
                {
                    if (contract.Value.Strike >= limitStrikeLow &&
                        contract.Value.Strike <= limitStrikeHigh)
                    {
                        flatContractIdList.Add(contract.Value.ConId);
                    }
                    return(true);
                });
                expiration.Value.Calls.All((contract) =>
                {
                    if (contract.Value.Strike >= limitStrikeLow &&
                        contract.Value.Strike <= limitStrikeHigh)
                    {
                        flatContractIdList.Add(contract.Value.ConId);
                    }
                    return(true);
                });
                return(true);
            });

            this.Log("Returning {0} option contracts.", flatContractIdList.Count);

            return(new TaskResultData(instruction, flatContractIdList.Count > 0, flatContractIdList));
        }