/// <summary>
/// Adds the specified time zone to this time keeper
/// </summary>
/// <param name="timeZone"></param>
public void AddTimeZone(DateTimeZone timeZone)
{
if (!_localTimeKeepers.ContainsKey(timeZone))
{
_localTimeKeepers[timeZone] = new LocalTimeKeeper(_utcDateTime, timeZone);
}
}
/// <summary>
/// Gets a <see cref="SecurityExchangeHours"/> instance that is always open
/// </summary>
public static SecurityExchangeHours AlwaysOpen(DateTimeZone timeZone)
{
var dayOfWeeks = Enum.GetValues(typeof (DayOfWeek)).OfType<DayOfWeek>();
return new SecurityExchangeHours(timeZone,
Enumerable.Empty<DateTime>(),
dayOfWeeks.Select(LocalMarketHours.OpenAllDay).ToDictionary(x => x.DayOfWeek)
);
}
/// <summary>
/// Gets the <see cref="CoarseFundamental"/> data for the specified market/date
/// </summary>
public static IEnumerable<CoarseFundamental> GetCoarseFundamentals(string market, DateTimeZone timeZone, DateTime date, bool isLiveMode)
{
var factory = new CoarseFundamental();
var config = new SubscriptionDataConfig(typeof(CoarseFundamental), SecurityType.Equity, new Symbol(market + "-coarse"), Resolution.Daily, market, timeZone, true, false, true, false);
var reader = new BaseDataSubscriptionFactory(config, date, isLiveMode);
var source = factory.GetSource(config, date, isLiveMode);
return reader.Read(source).OfType<CoarseFundamental>();
}
public TimeZone(string timeZoneId, Offset standardOffset, Offset wallOffset, NodaTime.DateTimeZone dateTimeZone)
{
base();
this.set_TimeZoneId(timeZoneId);
this.set_StandardOffset(standardOffset);
this.set_WallOffset(wallOffset);
this.set_DateTimeZone(dateTimeZone);
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScheduleManager"/> class
/// </summary>
/// <param name="securities">Securities manager containing the algorithm's securities</param>
/// <param name="timeZone">The algorithm's time zone</param>
public ScheduleManager(SecurityManager securities, DateTimeZone timeZone)
{
_securities = securities;
DateRules = new DateRules(securities);
TimeRules = new TimeRules(securities, timeZone);
// used for storing any events before the event schedule is set
_preInitializedEvents = new List<ScheduledEvent>();
}
/// <summary>
/// Constructs an instance from the given information.
/// </summary>
/// <remarks>
/// User code is unlikely to need to deliberately call this constructor except
/// possibly for testing.
/// </remarks>
/// <param name="localDateTime">The local date and time that was ambiguous</param>
/// <param name="zone">The time zone in which the mapping is ambiguous</param>
/// <param name="earlierMapping">The earlier possible mapping</param>
/// <param name="laterMapping">The later possible mapping</param>
public AmbiguousTimeException(LocalDateTime localDateTime, DateTimeZone zone,
ZonedDateTime earlierMapping,
ZonedDateTime laterMapping)
: base("Local time " + localDateTime + " is ambiguous in time zone " + zone.Id)
{
this.localDateTime = localDateTime;
this.zone = zone;
this.earlierMapping = earlierMapping;
this.laterMapping = laterMapping;
}
/// <summary>
/// Add Market Data Required (Overloaded method for backwards compatibility).
/// </summary>
/// <param name="symbol">Symbol of the asset we're like</param>
/// <param name="resolution">Resolution of Asset Required</param>
/// <param name="timeZone">The time zone the subscription's data is time stamped in</param>
/// <param name="exchangeTimeZone">Specifies the time zone of the exchange for the security this subscription is for. This
/// is this output time zone, that is, the time zone that will be used on BaseData instances</param>
/// <param name="isCustomData">True if this is custom user supplied data, false for normal QC data</param>
/// <param name="fillDataForward">when there is no data pass the last tradebar forward</param>
/// <param name="extendedMarketHours">Request premarket data as well when true </param>
/// <returns>The newly created <see cref="SubscriptionDataConfig"/></returns>
public SubscriptionDataConfig Add(Symbol symbol, Resolution resolution, DateTimeZone timeZone, DateTimeZone exchangeTimeZone, bool isCustomData = false, bool fillDataForward = true, bool extendedMarketHours = false)
{
//Set the type: market data only comes in two forms -- ticks(trade by trade) or tradebar(time summaries)
var dataType = typeof(TradeBar);
if (resolution == Resolution.Tick)
{
dataType = typeof(Tick);
}
return Add(dataType, symbol, resolution, timeZone, exchangeTimeZone, isCustomData, fillDataForward, extendedMarketHours, false);
}
public RestApiBaseData ToBaseData(DateTimeZone timeZone, TimeSpan period)
{
var dateTime = QuantConnect.Time.UnixTimeStampToDateTime(time).ConvertFromUtc(timeZone).Subtract(period);
return new RestApiBaseData
{
Symbol = symbol,
Time = dateTime,
EndTime = dateTime.Add(period),
Value = (decimal) alpha
};
}
public PullTests()
{
timeZone = DateTimeZoneProviders.Tzdb.GetSystemDefault();
store = new FakeStore();
storeFactory = new TestStoreFactory(store);
Emit(NewId<LocalCalendar>(),
new RemoteCalendarAdded(
new FakeRemote
{
Id = NewId<RemoteCalendar>()
}));
}
/// <summary>
/// Gets the history for the requested securities
/// </summary>
/// <param name="requests">The historical data requests</param>
/// <param name="sliceTimeZone">The time zone used when time stamping the slice instances</param>
/// <returns>An enumerable of the slices of data covering the span specified in each request</returns>
public IEnumerable<Slice> GetHistory(IEnumerable<HistoryRequest> requests, DateTimeZone sliceTimeZone)
{
foreach (var request in requests)
{
var granularity = ToGranularity(request.Resolution);
// Oanda only has 5-second bars, we return these for Resolution.Second
var period = request.Resolution == Resolution.Second ?
TimeSpan.FromSeconds(5) : request.Resolution.ToTimeSpan();
// set the starting date/time
var startDateTime = request.StartTimeUtc;
// loop until last date
while (startDateTime <= request.EndTimeUtc)
{
var start = startDateTime.ToString("yyyy-MM-ddTHH:mm:ssZ");
// request blocks of bars at the requested resolution with a starting date/time
var oandaSymbol = _symbolMapper.GetBrokerageSymbol(request.Symbol);
var candles = DownloadBars(oandaSymbol, start, MaxBarsPerRequest, granularity);
if (candles.Count == 0)
break;
foreach (var candle in candles)
{
var time = GetDateTimeFromString(candle.time);
if (time > request.EndTimeUtc)
break;
var tradeBar = new TradeBar(
time,
request.Symbol,
Convert.ToDecimal(candle.openMid),
Convert.ToDecimal(candle.highMid),
Convert.ToDecimal(candle.lowMid),
Convert.ToDecimal(candle.closeMid),
0,
period);
DataPointCount++;
yield return new Slice(tradeBar.EndTime, new[] { tradeBar });
}
// calculate the next request datetime
startDateTime = GetDateTimeFromString(candles[candles.Count - 1].time).Add(period);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SecurityExchangeHours"/> class
/// </summary>
/// <param name="timeZone">The time zone the dates and hours are represented in</param>
/// <param name="holidayDates">The dates this exchange is closed for holiday</param>
/// <param name="marketHoursForEachDayOfWeek">The exchange's schedule for each day of the week</param>
public SecurityExchangeHours(DateTimeZone timeZone, IEnumerable<DateTime> holidayDates, IReadOnlyDictionary<DayOfWeek, LocalMarketHours> marketHoursForEachDayOfWeek)
{
_timeZone = timeZone;
_holidays = holidayDates.Select(x => x.Date.Ticks).ToHashSet();
// make a copy of the dictionary for internal use
_openHoursByDay = new Dictionary<DayOfWeek, LocalMarketHours>(marketHoursForEachDayOfWeek.ToDictionary());
SetMarketHoursForDay(DayOfWeek.Sunday, out _sunday);
SetMarketHoursForDay(DayOfWeek.Monday, out _monday);
SetMarketHoursForDay(DayOfWeek.Tuesday, out _tuesday);
SetMarketHoursForDay(DayOfWeek.Wednesday, out _wednesday);
SetMarketHoursForDay(DayOfWeek.Thursday, out _thursday);
SetMarketHoursForDay(DayOfWeek.Friday, out _friday);
SetMarketHoursForDay(DayOfWeek.Saturday, out _saturday);
}
private static void DumpZone(DateTimeZone zone, Options options)
{
Console.Write("{0}\r\n", zone.Id);
var initial = zone.GetZoneInterval(Instant.MinValue);
Console.Write("Initially: {0} {1} {2}\r\n",
OffsetPattern.Format(initial.WallOffset),
initial.Savings != Offset.Zero ? "daylight" : "standard",
initial.Name);
foreach (var zoneInterval in zone.GetZoneIntervals(options.Start, options.End)
.Where(zi => zi.HasStart && zi.Start >= options.Start))
{
Console.Write("{0} {1} {2} {3}\r\n",
InstantPattern.Format(zoneInterval.Start),
OffsetPattern.Format(zoneInterval.WallOffset),
zoneInterval.Savings != Offset.Zero ? "daylight" : "standard",
zoneInterval.Name);
}
}
/// <summary>
/// Gets the <see cref="LocalTimeKeeper"/> instance for the specified time zone
/// </summary>
/// <param name="timeZone">The time zone whose <see cref="LocalTimeKeeper"/> we seek</param>
/// <returns>The <see cref="LocalTimeKeeper"/> instance for the specified time zone</returns>
public LocalTimeKeeper GetLocalTimeKeeper(DateTimeZone timeZone)
{
LocalTimeKeeper localTimeKeeper;
if (!_localTimeKeepers.TryGetValue(timeZone, out localTimeKeeper))
{
localTimeKeeper = new LocalTimeKeeper(UtcTime, timeZone);
_localTimeKeepers[timeZone] = localTimeKeeper;
}
return localTimeKeeper;
}
IFluentSchedulingRunnable IFluentSchedulingTimeSpecifier.At(TimeSpan timeOfDay, DateTimeZone timeZone)
{
return SetTimeRule(_schedule.TimeRules.At(timeOfDay, timeZone));
}
/// <summary>
/// Gets the history for the requested securities
/// </summary>
/// <param name="requests">The historical data requests</param>
/// <param name="sliceTimeZone">The time zone used when time stamping the slice instances</param>
/// <returns>An enumerable of the slices of data covering the span specified in each request</returns>
public IEnumerable<Slice> GetHistory(IEnumerable<HistoryRequest> requests, DateTimeZone sliceTimeZone)
{
foreach (var request in requests)
{
foreach (var slice in _historyPort.ProcessHistoryRequests(request))
{
yield return slice;
}
}
}
/// <summary>
/// Specifies an event should fire at the specified time of day in the specified time zone
/// </summary>
/// <param name="hour">The hour</param>
/// <param name="minute">The minute</param>
/// <param name="second">The second</param>
/// <param name="timeZone">The time zone the event time is represented in</param>
/// <returns>A time rule that fires at the specified time in the algorithm's time zone</returns>
public ITimeRule At(int hour, int minute, int second, DateTimeZone timeZone)
{
return At(new TimeSpan(hour, minute, second), timeZone);
}
/// <summary>
/// Constructor for Data Subscriptions
/// </summary>
/// <param name="objectType">Type of the data objects.</param>
/// <param name="symbol">Symbol of the asset we're requesting</param>
/// <param name="resolution">Resolution of the asset we're requesting</param>
/// <param name="timeZone">The time zone the raw data is time stamped in</param>
/// <param name="fillForward">Fill in gaps with historical data</param>
/// <param name="extendedHours">Equities only - send in data from 4am - 8pm</param>
/// <param name="isInternalFeed">Set to true if this subscription is added for the sole purpose of providing currency conversion rates,
/// setting this flag to true will prevent the data from being sent into the algorithm's OnData methods</param>
/// <param name="isCustom">True if this is user supplied custom data, false for normal QC data</param>
public SubscriptionDataConfig(Type objectType,
Symbol symbol,
Resolution resolution,
DateTimeZone timeZone,
bool fillForward,
bool extendedHours,
bool isInternalFeed,
bool isCustom = false)
{
Type = objectType;
SecurityType = symbol.ID.SecurityType;
Resolution = resolution;
_sid = symbol.ID;
FillDataForward = fillForward;
ExtendedMarketHours = extendedHours;
PriceScaleFactor = 1;
MappedSymbol = symbol.Value;
IsInternalFeed = isInternalFeed;
IsCustomData = isCustom;
Market = symbol.ID.Market;
TimeZone = timeZone;
Consolidators = new HashSet<IDataConsolidator>();
switch (resolution)
{
case Resolution.Tick:
//Ticks are individual sales and fillforward doesn't apply.
Increment = TimeSpan.FromSeconds(0);
FillDataForward = false;
break;
case Resolution.Second:
Increment = TimeSpan.FromSeconds(1);
break;
case Resolution.Minute:
Increment = TimeSpan.FromMinutes(1);
break;
case Resolution.Hour:
Increment = TimeSpan.FromHours(1);
break;
case Resolution.Daily:
Increment = TimeSpan.FromDays(1);
break;
default:
throw new InvalidEnumArgumentException("Unexpected Resolution: " + resolution);
}
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
this.navigationHelper.OnNavigatedFrom(e);
DateTimeZone = null;
Reminder = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="ZonedDateTime"/> struct.
/// </summary>
/// <param name="instant">The instant.</param>
/// <param name="zone">The time zone.</param>
/// <param name="calendar">The calendar system.</param>
public ZonedDateTime(Instant instant, DateTimeZone zone, CalendarSystem calendar)
{
this.zone = Preconditions.CheckNotNull(zone, nameof(zone));
offsetDateTime = new OffsetDateTime(instant, zone.GetUtcOffset(instant), Preconditions.CheckNotNull(calendar, nameof(calendar)));
}
/// <summary>
/// Initializes a new instance of the <see cref="ZonedDateTime" /> struct in the specified time zone
/// and the ISO calendar.
/// </summary>
/// <param name="instant">The instant.</param>
/// <param name="zone">The time zone.</param>
public ZonedDateTime(Instant instant, DateTimeZone zone)
{
this.zone = Preconditions.CheckNotNull(zone, nameof(zone));
offsetDateTime = new OffsetDateTime(instant, zone.GetUtcOffset(instant));
}
public ZonedDateTime InZone([NotNull] DateTimeZone zone) => // zone is checked for nullity by the constructor. new ZonedDateTime(this, zone);
public ZonedDateTime InZone(DateTimeZone zone)
{
Preconditions.CheckNotNull(zone, nameof(zone));
return(ToInstant().InZone(zone));
}
public ZonedDateTime InFixedZone() => new ZonedDateTime(this, DateTimeZone.ForOffset(Offset));
/// <summary>
/// Creates a new <see cref="ZonedClock"/> with the given clock, time zone and calendar system.
/// </summary>
/// <param name="clock">Clock to use to obtain instants.</param>
/// <param name="zone">Time zone to adjust instants into.</param>
/// <param name="calendar">Calendar system to use.</param>
public ZonedClock(IClock clock, DateTimeZone zone, CalendarSystem calendar)
{
this.clock = Preconditions.CheckNotNull(clock, nameof(clock));
this.zone = Preconditions.CheckNotNull(zone, nameof(zone));
this.calendar = Preconditions.CheckNotNull(calendar, nameof(calendar));
}
/// <summary>
/// Initializes a new instance of the <see cref="LocalTimeKeeper"/> class
/// </summary>
/// <param name="utcDateTime">The current time in UTC</param>
/// <param name="timeZone">The time zone</param>
internal LocalTimeKeeper(DateTime utcDateTime, DateTimeZone timeZone)
{
_timeZone = timeZone;
_localTime = new Lazy<DateTime>(() => utcDateTime.ConvertTo(DateTimeZone.Utc, _timeZone));
}
/// <summary>
/// Internal constructor from pre-validated values.
/// </summary>
internal ZonedDateTime(OffsetDateTime offsetDateTime, DateTimeZone zone)
{
this.offsetDateTime = offsetDateTime;
this.zone = zone;
}
/// <summary>
/// Creates a new <see cref="TimeSlice"/> for the specified time using the specified data
/// </summary>
/// <param name="utcDateTime">The UTC frontier date time</param>
/// <param name="algorithmTimeZone">The algorithm's time zone, required for computing algorithm and slice time</param>
/// <param name="cashBook">The algorithm's cash book, required for generating cash update pairs</param>
/// <param name="data">The data in this <see cref="TimeSlice"/></param>
/// <param name="changes">The new changes that are seen in this time slice as a result of universe selection</param>
/// <returns>A new <see cref="TimeSlice"/> containing the specified data</returns>
public static TimeSlice Create(DateTime utcDateTime, DateTimeZone algorithmTimeZone, CashBook cashBook, List<KeyValuePair<Security, List<BaseData>>> data, SecurityChanges changes)
{
int count = 0;
var security = new List<KeyValuePair<Security, BaseData>>();
var custom = new List<KeyValuePair<Security, List<BaseData>>>();
var consolidator = new List<KeyValuePair<SubscriptionDataConfig, List<BaseData>>>();
var allDataForAlgorithm = new List<BaseData>(data.Count);
var cash = new List<KeyValuePair<Cash, BaseData>>(cashBook.Count);
var cashSecurities = new HashSet<Symbol>();
foreach (var cashItem in cashBook.Values)
{
cashSecurities.Add(cashItem.SecuritySymbol);
}
Split split;
Dividend dividend;
Delisting delisting;
SymbolChangedEvent symbolChange;
var algorithmTime = utcDateTime.ConvertFromUtc(algorithmTimeZone);
var tradeBars = new TradeBars(algorithmTime);
var ticks = new Ticks(algorithmTime);
var splits = new Splits(algorithmTime);
var dividends = new Dividends(algorithmTime);
var delistings = new Delistings(algorithmTime);
var symbolChanges = new SymbolChangedEvents(algorithmTime);
foreach (var kvp in data)
{
var list = kvp.Value;
var symbol = kvp.Key.Symbol;
// keep count of all data points
if (list.Count == 1 && list[0] is BaseDataCollection)
{
count += ((BaseDataCollection) list[0]).Data.Count;
}
else
{
count += list.Count;
}
BaseData update = null;
var consolidatorUpdate = new List<BaseData>(list.Count);
for (int i = 0; i < list.Count; i++)
{
var baseData = list[i];
if (!kvp.Key.SubscriptionDataConfig.IsInternalFeed)
{
// this is all the data that goes into the algorithm
allDataForAlgorithm.Add(baseData);
if (kvp.Key.SubscriptionDataConfig.IsCustomData)
{
// this is all the custom data
custom.Add(kvp);
}
}
// don't add internal feed data to ticks/bars objects
if (baseData.DataType != MarketDataType.Auxiliary)
{
if (!kvp.Key.SubscriptionDataConfig.IsInternalFeed)
{
// populate ticks and tradebars dictionaries with no aux data
if (baseData.DataType == MarketDataType.Tick)
{
List<Tick> ticksList;
if (!ticks.TryGetValue(symbol, out ticksList))
{
ticksList = new List<Tick> {(Tick) baseData};
ticks[symbol] = ticksList;
}
ticksList.Add((Tick) baseData);
}
else if (baseData.DataType == MarketDataType.TradeBar)
{
tradeBars[symbol] = (TradeBar) baseData;
}
// this is data used to update consolidators
consolidatorUpdate.Add(baseData);
}
// this is the data used set market prices
update = baseData;
}
// include checks for various aux types so we don't have to construct the dictionaries in Slice
else if ((delisting = baseData as Delisting) != null)
{
delistings[symbol] = delisting;
}
else if ((dividend = baseData as Dividend) != null)
{
dividends[symbol] = dividend;
}
else if ((split = baseData as Split) != null)
{
splits[symbol] = split;
}
else if ((symbolChange = baseData as SymbolChangedEvent) != null)
{
// symbol changes is keyed by the requested symbol
symbolChanges[kvp.Key.SubscriptionDataConfig.Symbol] = symbolChange;
}
}
// check for 'cash securities' if we found valid update data for this symbol
// and we need this data to update cash conversion rates, long term we should
// have Cash hold onto it's security, then he can update himself, or rather, just
// patch through calls to conversion rate to compue it on the fly using Security.Price
if (update != null && cashSecurities.Contains(kvp.Key.Symbol))
{
foreach (var cashKvp in cashBook)
{
if (cashKvp.Value.SecuritySymbol == kvp.Key.Symbol)
{
cash.Add(new KeyValuePair<Cash, BaseData>(cashKvp.Value, update));
}
}
}
security.Add(new KeyValuePair<Security, BaseData>(kvp.Key, update));
consolidator.Add(new KeyValuePair<SubscriptionDataConfig, List<BaseData>>(kvp.Key.SubscriptionDataConfig, consolidatorUpdate));
}
var slice = new Slice(utcDateTime.ConvertFromUtc(algorithmTimeZone), allDataForAlgorithm, tradeBars, ticks, splits, dividends, delistings, symbolChanges, allDataForAlgorithm.Count > 0);
return new TimeSlice(utcDateTime, count, slice, data, cash, security, consolidator, custom, changes);
}
private static TimeRules GetTimeRules(DateTimeZone dateTimeZone)
{
var timeKeeper = new TimeKeeper(DateTime.Today, new List<DateTimeZone>());
var manager = new SecurityManager(timeKeeper);
var securityExchangeHours = SecurityExchangeHoursProvider.FromDataFolder().GetExchangeHours("usa", null, SecurityType.Equity);
var config = new SubscriptionDataConfig(typeof(TradeBar), SecurityType.Equity, "SPY", Resolution.Daily, "usa", securityExchangeHours.TimeZone, true, false, false);
manager.Add("SPY", new Security(securityExchangeHours, config, 1));
var rules = new TimeRules(manager, dateTimeZone);
return rules;
}
public ZonedDateTime WithZone(DateTimeZone targetZone)
{
Preconditions.CheckNotNull(targetZone, nameof(targetZone));
return(new ZonedDateTime(ToInstant(), targetZone, Calendar));
}
/// <summary>
/// Copy constructor with overrides
/// </summary>
/// <param name="config">The config to copy, then overrides are applied and all option</param>
/// <param name="objectType">Type of the data objects.</param>
/// <param name="securityType">SecurityType Enum Set Equity/FOREX/Futures etc.</param>
/// <param name="symbol">Symbol of the asset we're requesting</param>
/// <param name="resolution">Resolution of the asset we're requesting</param>
/// <param name="market">The market this subscription comes from</param>
/// <param name="timeZone">The time zone the raw data is time stamped in</param>
/// <param name="fillForward">Fill in gaps with historical data</param>
/// <param name="extendedHours">Equities only - send in data from 4am - 8pm</param>
/// <param name="isInternalFeed">Set to true if this subscription is added for the sole purpose of providing currency conversion rates,
/// setting this flag to true will prevent the data from being sent into the algorithm's OnData methods</param>
/// <param name="isCustom">True if this is user supplied custom data, false for normal QC data</param>
public SubscriptionDataConfig(SubscriptionDataConfig config,
Type objectType = null,
SecurityType? securityType = null,
Symbol symbol = null,
Resolution? resolution = null,
string market = null,
DateTimeZone timeZone = null,
bool? fillForward = null,
bool? extendedHours = null,
bool? isInternalFeed = null,
bool? isCustom = null)
: this(objectType ?? config.Type,
symbol ?? config.Symbol,
resolution ?? config.Resolution,
timeZone ?? config.TimeZone,
fillForward ?? config.FillDataForward,
extendedHours ?? config.ExtendedMarketHours,
isInternalFeed ?? config.IsInternalFeed,
isCustom ?? config.IsCustomData)
{
}
public void Deconstruct(out LocalDateTime localDateTime, out DateTimeZone dateTimeZone, out Offset offset)
{
localDateTime = LocalDateTime;
dateTimeZone = Zone;
offset = Offset;
}
/// <summary>
/// Specifies an event should fire at the specified time of day in the specified time zone
/// </summary>
/// <param name="timeOfDay">The time of day in the algorithm's time zone the event should fire</param>
/// <param name="timeZone">The time zone the date time is expressed in</param>
/// <returns>A time rule that fires at the specified time in the algorithm's time zone</returns>
public ITimeRule At(TimeSpan timeOfDay, DateTimeZone timeZone)
{
var name = string.Join(",", timeOfDay.TotalHours.ToString("0.##"));
Func<IEnumerable<DateTime>, IEnumerable<DateTime>> applicator = dates =>
from date in dates
let localEventTime = date + timeOfDay
let utcEventTime = localEventTime.ConvertToUtc(timeZone)
select utcEventTime;
return new FuncTimeRule(name, applicator);
}
/// <summary>
/// Creates a new instance for the given local date/time and time zone.
/// </summary>
/// <remarks>
/// User code is unlikely to need to deliberately call this constructor except
/// possibly for testing.
/// </remarks>
/// <param name="localDateTime">The local date/time which is skipped in the specified time zone.</param>
/// <param name="zone">The time zone in which the local date/time does not exist.</param>
public SkippedTimeException(LocalDateTime localDateTime, [NotNull] DateTimeZone zone)
: base("Local time " + localDateTime + " is invalid in time zone " + Preconditions.CheckNotNull(zone, nameof(zone)).Id)
{
this.LocalDateTime = localDateTime;
this.Zone = zone;
}
IFluentSchedulingRunnable IFluentSchedulingTimeSpecifier.At(int hour, int minute, int second, DateTimeZone timeZone)
{
return SetTimeRule(_schedule.TimeRules.At(hour, minute, second, timeZone));
}
/// <summary>
/// Constructor for Data Subscriptions
/// </summary>
/// <param name="objectType">Type of the data objects.</param>
/// <param name="securityType">SecurityType Enum Set Equity/FOREX/Futures etc.</param>
/// <param name="symbol">Symbol of the asset we're requesting</param>
/// <param name="resolution">Resolution of the asset we're requesting</param>
/// <param name="market">The market this subscription comes from</param>
/// <param name="timeZone">The time zone the raw data is time stamped in</param>
/// <param name="fillForward">Fill in gaps with historical data</param>
/// <param name="extendedHours">Equities only - send in data from 4am - 8pm</param>
/// <param name="isTradeBar">Set to true if the objectType has Open, High, Low, and Close properties defines, does not need to directly derive from the TradeBar class
/// This is used for the DynamicDataConsolidator</param>
/// <param name="hasVolume">Set to true if the objectType has a Volume property defined. This is used for the DynamicDataConsolidator</param>
/// <param name="isInternalFeed">Set to true if this subscription is added for the sole purpose of providing currency conversion rates,
/// setting this flag to true will prevent the data from being sent into the algorithm's OnData methods</param>
/// <param name="subscriptionIndex">The subscription index from the SubscriptionManager, this MUST equal the subscription's index or all hell will break loose!</param>
public SubscriptionDataConfig(Type objectType,
SecurityType securityType,
string symbol,
Resolution resolution,
string market,
DateTimeZone timeZone,
bool fillForward,
bool extendedHours,
bool isTradeBar,
bool hasVolume,
bool isInternalFeed,
int subscriptionIndex)
{
Type = objectType;
SecurityType = securityType;
Resolution = resolution;
Symbol = symbol.ToUpper();
FillDataForward = fillForward;
ExtendedMarketHours = extendedHours;
IsTradeBar = isTradeBar;
HasVolume = hasVolume;
PriceScaleFactor = 1;
MappedSymbol = symbol;
IsInternalFeed = isInternalFeed;
SubscriptionIndex = subscriptionIndex;
Market = market;
TimeZone = timeZone;
Consolidators = new HashSet<IDataConsolidator>();
// verify the market string contains letters a-Z
if (string.IsNullOrWhiteSpace(market))
{
throw new ArgumentException("The market cannot be an empty string.");
}
if (!Regex.IsMatch(market, @"^[a-zA-Z]+$"))
{
throw new ArgumentException("The market must only contain letters A-Z.");
}
switch (resolution)
{
case Resolution.Tick:
//Ticks are individual sales and fillforward doesn't apply.
Increment = TimeSpan.FromSeconds(0);
FillDataForward = false;
break;
case Resolution.Second:
Increment = TimeSpan.FromSeconds(1);
break;
case Resolution.Minute:
Increment = TimeSpan.FromMinutes(1);
break;
case Resolution.Hour:
Increment = TimeSpan.FromHours(1);
break;
case Resolution.Daily:
Increment = TimeSpan.FromDays(1);
break;
default:
throw new InvalidEnumArgumentException("Unexpected Resolution: " + resolution);
}
}
public static int DaysOff(string date, string time, string rpfTimeZone, string ingestTimeZone)
{
int tensPlace = 0;
DateTime localDt = DateTime.Parse(string.Format("{0} {1}", date, time));
LocalTime localTime = new LocalTime(localDt.Hour, localDt.Minute, localDt.Second);
int hour = localDt.Hour;
LocalDateTime localDateTime = LocalDateTime.FromDateTime(localDt);
DateTimeZoneProviders dtzp = new DateTimeZoneProviders();
DateTimeZone rpfZone = dtzp.Tzdb[rpfTimeZone];
DateTimeZone ingestZone = dtzp.Tzdb[ingestTimeZone];
ZonedDateTime zonedDateTime = localDateTime.InZoneLeniently(rpfZone);
Offset rpfOffset = rpfZone.GetUtcOffset(zonedDateTime.ToInstant());
Offset ingestOffset = ingestZone.GetUtcOffset(zonedDateTime.ToInstant());
ZonedDateTime zeroTime = new LocalDateTime(LocalDate.FromDateTime(localDt), new LocalTime(0, 15)).InZoneLeniently(ingestZone);
ZonedDateTime elevenTime = new LocalDateTime(LocalDate.FromDateTime(localDt), new LocalTime(11, 15)).InZoneLeniently(ingestZone);
ZonedDateTime zeroTimeRpf = new LocalDateTime(LocalDate.FromDateTime(localDt), new LocalTime(0, 15)).InZoneLeniently(rpfZone);
ZonedDateTime elevenTimeRpf = new LocalDateTime(LocalDate.FromDateTime(localDt), new LocalTime(11, 15)).InZoneLeniently(rpfZone);
Offset zeroOffset = zeroTimeRpf.Offset - zeroTime.Offset;
Offset elevenOffset = elevenTimeRpf.Offset - elevenTime.Offset;
if (Math.Abs(zeroOffset.Milliseconds) < Math.Abs(elevenOffset.Milliseconds))
{
var zeroClock = new LocalTime(0, 0);
var lowTime = zeroClock.PlusMilliseconds(-zeroOffset.Milliseconds);
var highTime = zeroClock.PlusMilliseconds(-elevenOffset.Milliseconds);
if (localTime >= lowTime && localTime < highTime)
{
tensPlace = 10;
}
}
/*
*
* at0 get offsets and subtract rpfoffat0 - ingestOffsetat0 (-4)
* at11 get offsets and subtract rpfoffat11 - ingestoffat11 (-5)
*
* if these are different
* range is (0 in time) - at0 or (0 - -4) = 4
* to (0 in time) -at11 or (0 - -5) = 5
*
*
*/
var offsetDelta = rpfOffset - ingestOffset;
var hrsToAdd = offsetDelta.Milliseconds / NodaConstants.MillisecondsPerHour;
var newHour = (hour + hrsToAdd);
if (newHour < 0)
{
return(-1 - tensPlace);
}
else if (newHour > 24)
{
return(1 + tensPlace);
}
else
{
return(0 + tensPlace);
}
}
public ZonedDateTime InZone([NotNull] DateTimeZone zone, [NotNull] CalendarSystem calendar)
{
Preconditions.CheckNotNull(zone, nameof(zone));
Preconditions.CheckNotNull(calendar, nameof(calendar));
return(new ZonedDateTime(this, zone, calendar));
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeRules"/> helper class
/// </summary>
/// <param name="securities">The security manager</param>
/// <param name="timeZone">The algorithm's default time zone</param>
public TimeRules(SecurityManager securities, DateTimeZone timeZone)
{
_securities = securities;
_timeZone = timeZone;
}
/// <summary>
/// Creates a new instance for the given local date/time and time zone.
/// </summary>
/// <remarks>
/// User code is unlikely to need to deliberately call this constructor except
/// possibly for testing.
/// </remarks>
/// <param name="localDateTime">The local date/time which is skipped in the specified time zone.</param>
/// <param name="zone">The time zone in which the local date/time does not exist.</param>
public SkippedTimeException(LocalDateTime localDateTime, DateTimeZone zone)
: base("Local time " + localDateTime + " is invalid in time zone " + zone.Id)
{
this.localDateTime = localDateTime;
this.zone = zone;
}
/// <summary>
/// Sets the default time zone
/// </summary>
/// <param name="timeZone">The time zone to use for helper methods that can't resolve a time zone</param>
public void SetDefaultTimeZone(DateTimeZone timeZone)
{
_timeZone = timeZone;
}
public Diary(IClock clock, CalendarSystem calendar, DateTimeZone timeZone)
{
_clock = clock;
_calendar = calendar;
_timeZone = timeZone;
}
/// <summary>
/// Gets the local time in the specified time zone. If the specified <see cref="DateTimeZone"/>
/// has not already been added, this will throw a <see cref="KeyNotFoundException"/>.
/// </summary>
/// <param name="timeZone">The time zone to get local time for</param>
/// <returns>The local time in the specifed time zone</returns>
public DateTime GetTimeIn(DateTimeZone timeZone)
{
return GetLocalTimeKeeper(timeZone).LocalTime;
}
/// <summary>
/// Gets the <see cref="LocalTimeKeeper"/> instance for the specified time zone
/// </summary>
/// <param name="timeZone">The time zone whose <see cref="LocalTimeKeeper"/> we seek</param>
/// <returns>The <see cref="LocalTimeKeeper"/> instance for the specified time zone</returns>
public LocalTimeKeeper GetLocalTimeKeeper(DateTimeZone timeZone)
{
return _localTimeKeepers[timeZone];
}
/// <summary>
/// Initializes a new instance of the <see cref="TimeZoneOffsetProvider"/> class
/// </summary>
/// <param name="timeZone">The time zone to provide offsets for</param>
/// <param name="utcStartTime">The start of the range of offsets</param>
/// <param name="utcEndTime">The en of the range of offsets</param>
public TimeZoneOffsetProvider(DateTimeZone timeZone, DateTime utcStartTime, DateTime utcEndTime)
{
_timeZone = timeZone;
// pad the end so we get the correct zone interval
utcEndTime += TimeSpan.FromDays(2*365);
var start = DateTimeZone.Utc.AtLeniently(LocalDateTime.FromDateTime(utcStartTime));
var end = DateTimeZone.Utc.AtLeniently(LocalDateTime.FromDateTime(utcEndTime));
var zoneIntervals = _timeZone.GetZoneIntervals(start.ToInstant(), end.ToInstant());
_discontinuities = new Queue<long>(zoneIntervals.Select(x => x.Start.ToDateTimeUtc().Ticks));
if (_discontinuities.Count == 0)
{
// end of discontinuities
_nextDiscontinuity = DateTime.MaxValue.Ticks;
_currentOffsetTicks = _timeZone.GetUtcOffset(Instant.FromDateTimeUtc(DateTime.UtcNow)).Ticks;
}
else
{
// get the offset just before the next discontinuity to initialize
_nextDiscontinuity = _discontinuities.Dequeue();
_currentOffsetTicks = _timeZone.GetUtcOffset(Instant.FromDateTimeUtc(new DateTime(_nextDiscontinuity - 1, DateTimeKind.Utc))).Ticks;
}
}