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;
}
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 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);
}
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));
}
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);
}
}
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));
}
