override public void Create()
{
m_cc = Carbon.Carbon.GetInstance().GetCarbonClientInstance();
tsCombineControl1.Create(m_cc, addGobutton_: true, doAutoSize_: true, showAddRemoveSeriesButtons_: false);
tsCombineControl1.GoClicked += btnGo_Click;
m_controls.Add(tsCombineControl1);
}
public static async Task<IReadOnlyList<ChildInstrument>> GetAll(ICarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null ? null : new ReadOnlyCollection<ChildInstrument>(_list);
}
public CarbonExcelWorker(ICarbonClient client, int interval = 100, int workerThreads = 0)
{
mClient = client;
mInterval = interval;
mCancellation = new CancellationTokenSource();
mStopWorking = new CancellationTokenSource();
mDequeueSignal = new AutoResetEvent(false);
mDisposeSyncObject = new object();
mDispatcherThread = new Thread(
ignored =>
{
SLog.log.InfoFormat("Managed Thread Id : {0}", Thread.CurrentThread.ManagedThreadId);
Pump();
}) {Name = "CarbonBackgroundWorker", IsBackground = true};
mDispatcherThread.Start();
var workerCount = workerThreads <= 0 ? Environment.ProcessorCount : workerThreads;
mThreads = new List<Thread>(workerCount);
for (var i = 1; i <= workerCount; i++)
{
var workerThread = new Thread(ProcessRequests) { IsBackground = true, Name = "CaronbRequestWorkr-" + i };
mThreads.Add(workerThread);
workerThread.Start();
}
SLog.log.InfoFormat("Created [{0}] worker threads to process requests.", workerCount);
}
public async Task Create(ICarbonClient cc_)
{
m_cc = cc_;
try
{
btnGo.Enabled = false;
await timeSeriesTreeWithFilter1.Create(cc_);
boundInfraGrid1.Bind(m_list);
boundInfraGrid1.SetHeaderClickSort();
tbStartYear.Bind(m_calArgs, "StartYear", new Validators.IntValidator());
tbEndYear.Bind(m_calArgs, "EndYear", new Validators.IntValidator());
tbOmitYears.Bind(m_calArgs, "OmitString", null);
cbCurrent.DataBindings.Add("Checked", m_args, "FindCurrentTrades");
cbNextTrades.DataBindings.Add("Checked", m_args, "FindNextTrades");
}
finally
{
btnGo.Enabled = true;
}
}
private static IReadOnlyDictionary<string, AnalyticsBondStaticData> BulkGetBondStaticDataFromCarbon(ICarbonClient client,
IReadOnlyCollection<string> bondIds)
{
if (bondIds == null || bondIds.Count == 0) return new Dictionary<string, AnalyticsBondStaticData>();
var dict = new ConcurrentDictionary<string, AnalyticsBondStaticData>();
var ids = new List<string>();
foreach (var id in bondIds)
{
AnalyticsBondStaticData data;
if (BondStaticDataCache.TryGetValue(id, out data))
{
dict.TryAdd(id, data);
}
else
{
var carbonBond = client.GetCachedCarbonBond(id);
if (carbonBond == null)
{
ids.Add(id);
}
else
{
var bond = ConvertCarbonBondToAnalyticsBondStaticData(carbonBond);
if (bond != null)
{
dict.TryAdd(id, bond);
BondStaticDataCache.TryAdd(id, bond);
BondStaticDataCache.TryAdd(bond.Id, bond);
}
else
{
ids.Add(id);
}
}
}
}
if (ids.Count == 0) return dict.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
var datas = client.BulkGetSecurityMetadataInternal(ids, "static-bond");
if (datas == null || datas.Count == 0) return dict.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
Parallel.ForEach(datas, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
data =>
{
var bond = ConvertCarbonBondStaticToAnalyticBondStatic(client, data);
if (bond != null)
{
BondStaticDataCache.TryAdd(bond.Id, bond);
BondStaticDataCache.TryAdd(data.Identifier, bond);
dict.TryAdd(bond.Id, bond);
}
});
return dict.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
}
public async Task<SysMetaLine> GetMeta(string subportfolioName_, ICarbonClient cc_, bool forceRefresh_ = false)
{
var meta = await GetMeta(cc_, forceRefresh_);
return meta == null || meta.Data == null
? null
: meta.Data.FirstOrDefault(x => string.Compare(x.Model, subportfolioName_) == 0);
}
public static async Task<ChildInstrument> GetByBbgTicker(string bbgTicker_, ICarbonClient cc_)
{
if (_list == null)
await populate(cc_);
return _list == null
? null
: _list.FirstOrDefault(x => string.Compare(bbgTicker_, x.BbgCode, StringComparison.OrdinalIgnoreCase) == 0);
}
public async Task Create(ICarbonClient cc_)
{
await getTreeControl().Create(cc_);
boundComboBox1.DropDownStyle = Infragistics.Win.DropDownStyle.DropDown;
getTreeControl().SelectedSeriesChanged -= handleNodSelected;
getTreeControl().SelectedSeriesChanged += handleNodSelected;
}
public async Task<SysTimeSeries> GetAllocation(ICarbonClient cc_, bool forceRefresh_ = false)
{
if (m_alloc!=null && !forceRefresh_)
return m_alloc.Value;
m_alloc = new TriedObject<SysTimeSeries>(await SysTimeSeries.GetAsync(string.Format("{0}.allocation", RootName), cc_));
OnPortfolioChunkUpdated(new PortfolioChunkUpdatedEventArgs(PortfolioChunk.Allocation));
return m_alloc.Value;
}
public async Task<SysMeta> GetMeta(ICarbonClient cc_, bool forceRefresh_=false)
{
if (m_meta!=null && !forceRefresh_)
return m_meta.Value;
m_meta = new TriedObject<SysMeta>(await SysMeta.GetAsync(string.Format("{0}.meta", RootName), cc_));
OnPortfolioChunkUpdated(new PortfolioChunkUpdatedEventArgs(PortfolioChunk.Meta));
return m_meta.Value;
}
public async Task UpdateList(IList<SeriesConfig> list_, ICarbonClient client_)
{
// remove current items
var currentItems = list_.Where(x => x.Source != null && x.Source.ToLower().Equals(SourceName)).ToArray();
foreach (var item in currentItems)
list_.Remove(item);
var portfolio = new Portfolio("ssys.portfolio", null, 10000d);
await addPortfolio(portfolio, list_, client_);
}
public ContextMenuItem(IContextMenuDefinition def_, BaseTreeNode node_, ICarbonClient cc_)
{
Text = def_.ItemText(node_);
if(def_.ItemImage!=null) Image = def_.ItemImage(node_);
m_node = node_;
m_definition = def_;
m_cc = cc_;
Click += handleClick;
}
public async Task RemoveList(string listName_, ICarbonClient cc_)
{
var list = await GetConfigList(cc_);
BbgLists.RemoveMentionofList(list, listName_);
await saveList(list, cc_);
m_configs = list;
OnCacheRebuilt(EventArgs.Empty);
}
public async Task UpdateList(string listName_, IEnumerable<Tuple<string, string>> tickersAndFields_, ICarbonClient cc_)
{
var list = await GetConfigList(cc_);
BbgLists.UpdateBbgList(list, listName_, tickersAndFields_);
await saveList(list, cc_);
m_configs = list;
OnCacheRebuilt(EventArgs.Empty);
}
public async Task<DatedDataCollectionGen<double>> GetAllocationTo(string subPortfolioName_, ICarbonClient cc_, bool forceRefresh_ = false)
{
var alloc = await GetAllocation(cc_, forceRefresh_);
if (alloc == null || alloc.Data==null || !alloc.Data.Keys.Any()) return null;
int index = alloc.FindColumnIndex(subPortfolioName_);
if (index == -1) return null;
return new DatedDataCollectionGen<double>(alloc.Data.Keys.ToArray(), alloc.Data.GetColumnValues(index));
}
public async Task<ITimeSeries> RetrieveForMoniker(string moniker_, ICarbonClient cc_, bool forceRefresh_ = false)
{
ITimeSeries ret=null;
foreach (var source in m_sublists)
{
ret = await source.RetrieveForMoniker(moniker_, cc_, forceRefresh_);
if (ret != null) break;
}
return ret;
}
public async Task Create(ICarbonClient cc_)
{
await readConfigTree(cc_);
rebuildTree();
m_contextMenuDefinitions.Add(new ContextMenuDefinitionAddBbgList());
m_contextMenuDefinitions.Add(new ContextMenuDefinitionEditBbgList());
m_contextMenuDefinitions.Add(new ContextMenuDefinitionRemoveBbgList());
m_contextMenuDefinitions.Add(new ContextMenuDefinitionPlotSeries());
m_contextMenuDefinitions.Add(new ContextMenuDefinitionRefreshFromServer());
m_cc = cc_;
}
public async Task Create(ICarbonClient cc_)
{
await timeSeriesTree1.Create(cc_);
timeSeriesTree1.FilterDelayMilliseconds = 500;
m_args.PropertyChanged += (x, y) =>
{
timeSeriesTree1.FilterString = m_args.FilterString;
};
boundTextBox1.Bind(m_args, "FilterString", null);
}
public async Task UpdateList(IList<SeriesConfig> list_, ICarbonClient client_)
{
// remove current items
var currentItems = list_.Where(x => x.Source != null && x.Source.ToLower().Equals(SourceName)).ToArray();
foreach (var item in currentItems)
list_.Remove(item);
// search for frames that match the regex
Logger.Info(string.Format("Searching for dataframes with regex=[{0}]", MonikerSearchRegex),
typeof (DataframeSearcherBase));
var monikers = await client_.GetSavedIdentifiersAsync("AdHocData", MonikerSearchRegex, true);
foreach (var moniker in monikers)
{
Logger.Info(string.Format("Considering [{0}]...", moniker), typeof (DataframeSearcherBase));
try
{
var frame = await client_.GetFrameAsync<DateTime>(moniker);
foreach (var columnName_ in frame.ColumnKeys)
{
try
{
// attempt to try and get a timeseries
var series = frame.ExtractTimeSeries<double>(columnName_);
if (series == null) continue;
var config = getConfigLine(moniker, columnName_);
if (config == null) continue;
list_.Add(config);
}
catch
{
//Logger.Info(string.Format("Not going to add column [{0}] as can't get doubles from it", columnName_),
// typeof (DataframeSearcherBase));
}
}
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error getting and reflecting on frame {0}", moniker),
typeof (DataframeSearcherBase), ex_);
}
}
}
public async Task<DatedDataCollectionGen<double>> Extract(SeriesConfig line_, ICarbonClient cc_, bool forceRefresh_ = false)
{
var keys = line_.Parameters.Split('*').Select(x => x.Split(':')).ToDictionary(x => x[0], x => x[1]);
string frameMoniker = keys[CommonConstants._frameField];
var frame = await DataFrameCache.Get<DateTime>(frameMoniker, cc_, forceRefresh_);
if (frame == null) return null;
var con = frame.ToConstructGenGen<DateTime, double>();
return con == null ? null : con.SumRows().ToCumulative();
}
public async Task Create(ICarbonClient cc_, bool showDelete_=true, bool autoSize_=true)
{
await timeSeriesTreeDropdown1.Create(cc_);
pbDelete.Visible = showDelete_;
tbMult.Bind(m_args, "Mult", new Validators.DoubleValidator(null));
if (autoSize_)
{
timeSeriesTreeDropdown1.SetAutosize(150, 500);
timeSeriesTreeDropdown1.SizeChanged += handleResize;
tbMult.SetAutosize(30, 60);
tbMult.SizeChanged += handleResize;
handleResize(null, null);
}
}
public async Task UpdateList(IList<SeriesConfig> list_, ICarbonClient client_)
{
// remove current items
var currentItems = list_.Where(x => x.Source != null && x.Source.ToLower().Equals(SourceName)).ToArray();
foreach (var item in currentItems)
list_.Remove(item);
var trs = await InstrumentList_Children.GetAll(client_);
foreach (var tr in trs)
list_.Add(DataFrameColumnValue.CreateConfig(
dataframeMoniker_: tr.PriceSeriesMoniker,
dataframecolumnName_: _valueColumn,
treePath_: string.Format(@"TRs\{0}\{1}\{2}", tr.AssetClass, tr.Sector, tr.Key),
sourceName_: SourceName,
moniker_: string.Format("trs.{0}.{1}.{2}", tr.AssetClass, tr.Sector, tr.Key)));
}
public async Task<SeriesExtractResult> GetSelectedSeries(ICarbonClient client_)
{
var series = await timeSeriesTreeDropdown1.GetSelectedSeries(client_);
if (series == null) return null;
// if there was an error, then pass that back up
if (!string.IsNullOrEmpty(series.ErrorMessage) || series.Series==null || series.Series.Series==null )
return series;
var myseries = series.Series.Series.MultiplyBy(m_args.Mult);
var name = Math.Abs(m_args.Mult - 1d).IsZero()
? series.Series.Name
: string.Format("{0} x {1}", m_args.Mult.ToString("##0.0#"), series.Series.Name);
return new SeriesExtractResult(new TimeSeriesImpl(myseries, string.Format("[{0}]", name)));
}
public static async Task<SysTimeSeries> GetAsync(string name_, ICarbonClient cc_, double multiplier_=1d)
{
ConstructGenGen<DateTime, double> con;
try
{
con = await DataFrameHelper.GetDataFrameCellByCell<DateTime, double>(
name_: name_,
keyExtractor_: x =>
{
if (x is DateTime)
return (DateTime)x;
var d = DateTime.MinValue;
if (x is string)
if (DateTime.TryParseExact((string)x, "yyyy-MM-ddTHH:mm:ss.fffZ", CultureInfo.InvariantCulture,
DateTimeStyles.None, out d))
return d;
return DateTime.MinValue;
},
valueExtractor_: x =>
{
if (x is IConvertible)
return Convert.ToDouble(x)*multiplier_;
return 0d;
},
cc_: cc_);
// make sure dates are in order
if(con!=null)
con.Keys.Sort((a, b) => a.CompareTo(b));
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error extracting timeSeries from expando for [{0}]", name_), typeof (SysTimeSeries),
ex_);
con = null;
}
return con != null ? new SysTimeSeries {Data = con} : null;
}
private async Task addPortfolio(Portfolio p_, IList<SeriesConfig> list_, ICarbonClient cc_)
{
if (p_ == null) return;
var children = await p_.GetChildren(cc_);
var adjustedMoniker = p_.RootName.Replace("ssys.portfolio.",string.Empty);
var split = adjustedMoniker.Split('.');
list_.Add(DataFrameSumColumns.CreateConfig(
dataframeMoniker_: p_.PnlMoniker,
treePath_: string.Format(@"Systematic Strategy Pnl\{0}", string.Join(@"\", split)),
moniker_: string.Format("ssys.{0}.pnl", string.Join(".", split)),
sourceName_: SourceName));
if(children!=null)
foreach (var child in children)
await addPortfolio(child, list_, cc_);
}
private static async Task populate(ICarbonClient cc_)
{
var con = await DataFrameHelper.GetDataFrameByRow(
name_: MONIKER,
keyExtractor_: x => x,
valueExtractor_: (dict, col) => new ChildInstrument(col[dict["bbgCode"]] as string)
{
BbgCode = col[dict["bbgCode"]] as string,
Sector = col[dict["sector"]] as string,
AssetClass = col[dict["asset_class"]] as string,
},
cc_: cc_);
if (con != null)
{
foreach (var key in con.Keys)
con.GetValue(key, 0).Key = key as string;
_list = con.GetColumnValues(0).ToList();
}
}
getCTDMoniker(string country, string futureticker, ICarbonClient client)
// ----------------------------------------------------------------------------------------
{
string defaultmoniker = "symapp.roll.ctd";
country = country.ToLower();
// Column mappings
var col_prefixes = new Dictionary<string, string>() {{"front", ""}, {"back", "o"}};
// Get right cols and monikers
var parts = futureticker.Split('.');
if (parts.Length !=2)
throw new ArgumentException("#Error: Invalid futures name " + futureticker);
string month = parts[1].ToLower();
string ticker = parts[0].ToLower();
if (!col_prefixes.ContainsKey(month))
throw new ArgumentException("#Error: Invalid futures name " + futureticker);
string prefix = col_prefixes[month];
var tickercol = prefix + "ticker";
var pricecol = prefix + "price";
var moniker = defaultmoniker + "." + country + "." + ticker;
// Check to see if it's valid
var list = client.GetSavedIdentifiersAsync("AdHocData",defaultmoniker + @".*").Result;
var checks = new HashSet<string>(list);
if (!checks.Contains(moniker))
{
throw new ArgumentException("#Error: Invalid moniker entered " + moniker);
}
return new Tuple<string, string, string>(moniker, tickercol,pricecol);
}
public async Task<SeriesExtractResult> GetSelectedSeries(ICarbonClient cc_)
{
if (string.IsNullOrEmpty(boundComboBox1.Text)) return new SeriesExtractResult("No series specified");
if (!SeriesList.Instance.MonikerExists(boundComboBox1.Text))
return new SeriesExtractResult(errorMessage_: string.Format("Given moniker '{0}' is not valid", boundComboBox1.Text));
try
{
var series = await SeriesList.Instance.RetrieveForMoniker(boundComboBox1.Text, cc_);
return new SeriesExtractResult(series);
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error extracting series for moniker '{0}'", boundComboBox1.Text),
typeof (TimeSeriesTreeDropdown), ex_);
return
new SeriesExtractResult(
errorMessage_:
string.Format("There was an unknown error extracting the series for moniker '{0}'", boundComboBox1.Text));
}
}
public void Create(ICarbonClient cc_, bool addGobutton_=true, bool showAddRemoveSeriesButtons_=false, bool doAutoSize_=true)
{
m_cc = cc_ ?? new CarbonClient("PRD");
if (addGobutton_)
{
m_btn = new Button
{
Text = "GO"
};
m_btn.Click += handleGoClicked;
flowLayoutPanel1.Controls.Add(m_btn);
}
if (showAddRemoveSeriesButtons_ == false)
{
pbPlus.Visible = pbMinus.Visible = false;
flowLayoutPanel1.Dock = DockStyle.Fill;
}
m_doAutosize = doAutoSize_;
if (doAutoSize_) setSize();
}
getCTMoniker(string country, string benchmark, ICarbonClient client)
// ----------------------------------------------------------------------------------------
{
string defaultmoniker = "symapp.roll.ct";
country = country.ToLower();
var moniker = defaultmoniker + "." + country + "." + benchmark.ToLower();
var tickercol = "ticker"; // always OTR
var pricecol = "price";
// Check to see if it's valid
var list = client.GetSavedIdentifiersAsync("AdHocData",defaultmoniker + @".*").Result;
var checks = new HashSet<string>(list);
if (!checks.Contains(moniker))
{
throw new ArgumentException("#Error: Invalid moniker entered " + moniker);
}
return new Tuple<string, string, string>(moniker, tickercol,pricecol);
}
