internal Source(Fred fred) : base(fred)
{
_releases = new Lazy <List <Release> >(
() =>
{
var releases = (List <Release>)Fred.GetSourceReleases(Id);
var count = releases.Count;
var call = 1;
while (count == CallLimit)
{
var more = (List <Release>)Fred.GetSourceReleases(Id, DateTime.Today, DateTime.Today, CallLimit, call * CallLimit);
releases.AddRange(more);
count = more.Count;
call++;
}
return(releases);
});
}
internal Release(Fred fred) : base(fred)
{
_series = new Lazy <Task <List <Series> > >(
async() =>
{
var series = (List <Series>) await Fred.GetReleaseSeriesAsync(Id, RealtimeStart, RealtimeEnd);
var count = series.Count;
var call = 1;
while (count == CallLimit)
{
var more = (List <Series>) await Fred.GetReleaseSeriesAsync(Id, DateTime.Today, DateTime.Today, CallLimit, call * CallLimit);
series.AddRange(more);
count = more.Count;
call++;
}
return(series);
}
);
}
internal Category(Fred fred) : base(fred)
{
_childern = new Lazy <Task <IEnumerable <Category> > >(async() => await Fred.GetCategoryChildernAsync(Id));
_parent = new Lazy <Task <Category> >(async() => Id == 0 ? this : await Fred.GetCategoryAsync(ParentId));
_related = new Lazy <Task <IEnumerable <Category> > >(async() => await Fred.GetCategoryRelatedAsync(Id));
_series = new Lazy <Task <List <Series> > >(
async() =>
{
var series = (List <Series>) await Fred.GetCategorySeriesAsync(Id, DateTime.Today, DateTime.Today);
var count = series?.Count;
var call = 1;
while (count == CallLimit)
{
var more = (List <Series>) await Fred.GetCategorySeriesAsync(Id, DateTime.Today, DateTime.Today, CallLimit, call * CallLimit);
series.AddRange(more);
count = more.Count;
call++;
}
return(series);
}
);
}
internal Series(Fred fred) : base(fred)
{
_categories = new Lazy <IEnumerable <Category> >(() => UseRealtimeFields
? Fred.GetSeriesCategories(Id, RealtimeStart, RealtimeEnd)
: Fred.GetSeriesCategories(Id));
_release = new Lazy <Release>(() => UseRealtimeFields
? Fred.GetSeriesRelease(Id, RealtimeStart, RealtimeEnd)
: Fred.GetSeriesRelease(Id));
_data = new Lazy <List <Observation> >(
() =>
{
const int limit = 100000;
var data = UseRealtimeFields
? (List <Observation>)
Fred.GetSeriesObservations(Id, ObservationStart, ObservationEnd, RealtimeStart,
RealtimeEnd, Enumerable.Empty <DateTime>())
: (List <Observation>)
Fred.GetSeriesObservations(Id, ObservationStart, ObservationEnd);
var count = data.Count;
var call = 1;
while (count == limit)
{
var start = UseRealtimeFields ? RealtimeStart : Fred.CstTime();
var end = UseRealtimeFields ? RealtimeEnd : Fred.CstTime();
var more =
(List <Observation>)
Fred.GetSeriesObservations(Id, ObservationStart, ObservationEnd, start,
end, Enumerable.Empty <DateTime>(), limit,
call * limit);
data.AddRange(more);
count = more.Count;
call++;
}
return(data);
});
}
internal Category(Fred fred) : base(fred)
{
_childern = new Lazy<Task<IEnumerable<Category>>>(async () => await Fred.GetCategoryChildernAsync(Id));
_parent = new Lazy<Task<Category>>(async () => Id == 0 ? this : await Fred.GetCategoryAsync(ParentId));
_related = new Lazy<Task<IEnumerable<Category>>>(async () => await Fred.GetCategoryRelatedAsync(Id));
_series = new Lazy<Task<List<Series>>>(
async () =>
{
var series = (List<Series>) await Fred.GetCategorySeriesAsync(Id, DateTime.Today, DateTime.Today);
var count = series?.Count;
var call = 1;
while (count == CallLimit)
{
var more = (List<Series>) await Fred.GetCategorySeriesAsync(Id, DateTime.Today, DateTime.Today, CallLimit, call*CallLimit);
series.AddRange(more);
count = more.Count;
call++;
}
return series;
}
);
}
internal Source(Fred fred) : base(fred)
{
}
static void Main(string[] args)
{
var fred = new Fred("661c0a90e914477da5a7518293de5f8e");
int startYear;
int endYear;
int startMonth;
int endMonth;
int deflateYear = 0;
var data = new Dictionary<string, IList<Observation>>
{
};
//get year of rGDP dollars
//if (data.ContainsKey("rGDP"))
{
//var series = data["rGDP"];
var series = fred.GetSeries("GDPC1");
var units = series.Units;
//Console.WriteLine("Units: ");
//Console.WriteLine(units);
//string resultString = Regex.Match(units, @"\d+").Value;
deflateYear = extractNumber(series.Units);
Console.WriteLine("deflate year: {0}", deflateYear.ToString());
}
string entry;
WriteLine("Pushing ENTER accepts default values");
Write("Enter start year [2005]: ");
entry = ReadLine();
if (entry == "")
{
entry = "2005";
}
startYear = Convert.ToInt32(entry);
WriteLine("Enter end year [2015] ");
Write("years must cover rGDP real year to deinflate: ");
entry = ReadLine();
if (entry == "")
{
entry = "2015";
}
endYear = Convert.ToInt32(entry);
Write("Enter start month, ex. Jan = 1 or Oct = [10]: ");
entry = ReadLine();
if (entry == "")
{
entry = "10";
}
startMonth = Convert.ToInt32(entry);
Write("Enter end month, ex. Jan = 1 or Oct = [10]: ");
entry = ReadLine();
if (entry == "")
{
entry = "10";
}
endMonth = Convert.ToInt32(entry);
DateTime startDate = new DateTime(startYear, startMonth, 1);
DateTime endDate = new DateTime(endYear, endMonth, DateTime.DaysInMonth(endYear, endMonth));
//can't use # in GetSeriesObservations. Ignores the dates.
//my names
string[] dataNames = new string[] { "rGDP", "pSaveRate", "fedFundRate", "empPopRatio", "consConfIndex", "consPriceIndex", "housingSeries" };
//online series names
string[] obsNames = new string[] { "GDPC1", "PSAVERT", "DFF", "EMRATIO", "UMCSENT", "CP0000USM086NEST", "SPCS20RSA" };
int dataCounter = 0;
//create lists as FredAPI objects
foreach (var instance in dataNames)
{
if (dataNames[dataCounter] == "rGDP")
{
data.Add(dataNames[dataCounter], fred.GetSeriesObservations(obsNames[dataCounter], startDate, endDate).ToList());
}
else
{
data.Add(dataNames[dataCounter], fred.GetSeriesObservations(obsNames[dataCounter], startDate, endDate, frequency: Frequency.Monthly).ToList());
}
dataCounter++;
};
//MinMaxDates(ref data);
//convert data to sortedList (the DateTime becomes key of the SortedList), the string is the Key of the Dictionary.
var sortedDataList = new Dictionary<string, SortedList<DateTime, double?>> { };
dataCounter = 0;
foreach (var obData in data)
{
var list = obData.Value;
sortedDataList.Add(dataNames[dataCounter], new SortedList<DateTime, double?>(list.ToDictionary(x => x.Date, x => x.Value)));
dataCounter++;
}
//print data before changes
//PrintData(sortedDataList); - will crash now because of gaps in rGDP
//insert records (into rGDP)
//ideally might want to have this second.
FillInGaps(ref sortedDataList);
//identify minmax dates, and trim list, if ran before FillInGaps, rGDP doesn't populate up till HighestDate2
MinMaxDates(ref sortedDataList);
PrintData(sortedDataList);
PrintDataToFile(sortedDataList, "preConversion");
//deInflate
deInflate(ref sortedDataList, deflateYear);
PrintData(sortedDataList);
PrintDataToFile(sortedDataList, "postConversion");
parseData(sortedDataList, args);
}
internal Series(Fred fred) : base(fred)
{
}
internal Category(Fred fred) : base(fred)
{
}
internal Release(Fred fred) : base(fred)
{
}
internal Category(Fred fred) : base(fred)
{
}
