def _get_assistance_week(self):
w = Week()
w.set_day(0, TimeRange(Time(13, 30), Time(17)))
w.set_day(1, TimeRange(Time(6, 30), Time(8, 30)))
w.set_day(2, TimeRange(Time(7), Time(17)))
w.set_day(3, TimeRange(Time(6, 30), Time(8, 30)))
return w
def __init__(self, name, start_time, end_time, ticket_price, capacity, category="improv"):
self.__name = name
self.__show_time_range = TimeRange(start_time, end_time)
self.__ticket_price = ticket_price
self.__category = category
self.__capacity = capacity
self.__patrons = []
def test_can_return_week(self):
m = Month(2012, 10)
w = Week()
w.set_day(0, TimeRange(Time(7), Time(17)))
m.add_week(40, w)
self.assertEquals(
m.get_week(40).get_day(0), TimeRange(Time(7), Time(17)))
def test_can_enter_times_into_first_incomplete_week(self):
m = Month(2012, 11)
w = Week()
w.set_day(0, TimeRange(Time(7), Time(17)))
w.set_day(3, TimeRange(Time(8), Time(18)))
m.add_week(44, w)
self.assertEquals(m.get_day(1), TimeRange(Time(8), Time(18)))
def test_can_return_half_week(self):
m = Month(2012, 11)
w = Week()
w.set_day(2, TimeRange(Time(7), Time(17)))
w.set_day(3, TimeRange(Time(8), Time(18)))
m.add_week(44, w)
self.assertEquals(m.get_week(44).get_day(2), None)
def test_can_enter_times_from_last_week_in_month(self):
m = Month(2012, 10)
w = Week()
w.set_day(2, TimeRange(Time(7), Time(17)))
w.set_day(3, TimeRange(Time(7), Time(17)))
m.add_week(44, w)
self.assertEquals(m.get_day(31), TimeRange(Time(7), Time(17)))
self.assertNotEquals(m.get_day(32), TimeRange(Time(7), Time(17)))
def test_can_generate_realistic_monthly_report(self):
y = Year(2012)
blocked = self._get_daycare_week()
taken = self._get_assistance_week()
for i in [40, 41, 42, 43, 44]:
y.add_blocked(i, blocked)
y.add_taken(i, taken)
m = y.generate_montly_report(10, Hours(57, 50))
self.assertEquals(m.get_day(1), TimeRange(Time(17), Time(20)))
self.assertEquals(m.get_day(2), TimeRange(Time(13, 30), Time(20)))
def test_respects_both_blocked_and_taken_weeks(self):
y = Year(2012)
blocked = Week()
blocked.set_day(0, TimeRange(Time(8, 30), Time(13, 30)))
y.add_blocked(40, blocked)
taken = Week()
taken.set_day(1, TimeRange(Time(7), Time(17)))
y.add_taken(40, taken)
w = y.get_schedule_for_week(40, Hours(57, 50))
self.assertEquals(w.get_day(0).get_start(), Time(13, 30))
self.assertEquals(w.get_day(1).get_start(), Time(17))
def test_can_give_total_time_for_month(self):
m = Month(2012, 10)
w = Week()
w.set_day(4, TimeRange(Time(7), Time(17, 10)))
m.add_week(40, w)
m.add_week(42, w)
self.assertEquals(m.get_total_time(), Hours(20, 20))
def __init__(self, refTime=None, fcstTime=None, validPeriod=None):
self.fcstTime = int(fcstTime) if fcstTime is not None else 0
self.refTime = refTime if refTime is not None else None
if validPeriod is not None and type(validPeriod) is not TimeRange:
ValueError("Invalid validPeriod object specified for DataTime.")
self.validPeriod = validPeriod if validPeriod is not None else None
self.utilityFlags = EnumSet('com.raytheon.uf.common.time.DataTime$FLAG')
self.levelValue = numpy.float64(-1.0)
if self.refTime is not None:
if isinstance(self.refTime, datetime.datetime):
self.refTime = long(calendar.timegm(self.refTime.utctimetuple()) * 1000)
elif isinstance(self.refTime, time.struct_time):
self.refTime = long(calendar.timegm(self.refTime) * 1000)
elif hasattr(self.refTime, 'getTime'):
# getTime should be returning ms, there is no way to check this
# This is expected for java Date
self.refTime = long(self.refTime.getTime())
else:
self.refTime = long(refTime)
self.refTime = Date(self.refTime)
if self.validPeriod is None:
validTimeMillis = self.refTime.getTime() + long(self.fcstTime * 1000)
self.validPeriod = TimeRange()
self.validPeriod.setStart(validTimeMillis / 1000)
self.validPeriod.setEnd(validTimeMillis / 1000)
# figure out utility flags
if fcstTime:
self.utilityFlags.add("FCST_USED")
if self.validPeriod and self.validPeriod.isValid():
self.utilityFlags.add("PERIOD_USED")
def test_uses_blocked_week_when_scheduling(self):
y = Year(2012)
blocked = Week()
blocked.set_day(0, TimeRange(Time(8, 30), Time(13, 30)))
y.add_blocked(40, blocked)
w = y.get_schedule_for_week(40, Hours(57, 50))
self.assertEquals(w.get_day(0).get_start(), Time(13, 30))
def test_uses_taken_week_when_scheduling(self):
y = Year(2012)
taken = Week()
taken.set_day(0, TimeRange(Time(13, 30), Time(17)))
y.add_taken(40, taken)
w = y.get_schedule_for_week(40, Hours(57, 50))
self.assertEquals(w.get_day(0).get_start(), Time(17))
def test_doesnt_schedule_hours_scheduled_by_taken_week(self):
y = Year(2012)
taken = Week()
taken.set_day(0, TimeRange(Time(13, 30), Time(17)))
y.add_taken(40, taken)
w = y.get_schedule_for_week(40, Hours(47, 50))
self.assertEquals(w.get_total_time(), Hours(44, 20))
def test_can_generate_monthly_report_for_december(self):
y2012 = Year(2012)
y2013 = Year(2013)
y2012.set_next_year(y2013)
blocked = self._get_daycare_week()
taken = self._get_assistance_week()
y2013.add_blocked(1, blocked)
y2013.add_taken(1, taken)
m = y2012.generate_montly_report(12, Hours(48, 0))
self.assertEquals(m.get_day(31), TimeRange(Time(17), Time(20)))
def test_returns_correctly_annotated_week_for_start_of_month(self):
m = Month(2012, 11)
w = Week()
for i in xrange(7):
w.set_day(i, TimeRange(Time(7), Time(17)))
m.add_week(44, w)
aw = m.get_week(44)
self.assertEquals(aw.get_earliest_day_in_month(), 1)
self.assertEquals(aw.get_first_valid_day(), 3)
self.assertEquals(aw.get_last_valid_day(), 6)
class Show:
def __init__(self, name, start_time, end_time, ticket_price, capacity, category="improv"):
self.__name = name
self.__show_time_range = TimeRange(start_time, end_time)
self.__ticket_price = ticket_price
self.__category = category
self.__capacity = capacity
self.__patrons = []
def get_name(self):
return self.__name
def get_start_time(self):
return self.__show_time_range.get_start_time()
def get_end_time(self):
return self.__show_time_range.get_start_time()
def get_show_time_range(self):
return self.__show_time_range
def get_category(self):
return self.__category
def get_capacity(self):
return self.__capacity
def get_patrons(self):
return self.__patrons
def get_number_of_patrons(self):
return len(self.__patrons)
def add_patron(self, patron):
if len(self.__patrons) >= self.get_capacity():
return False
else:
self.__patrons.append(patron)
return True
def get_ticket_price(self):
return self.__ticket_price
def generate_day(hours, taken=None, latest_time=None):
if taken != None:
start = taken.get_end()
else:
start = DEFAULT_EARLIEST_TIME
new_end = start.add_hours(hours)
if latest_time != None and new_end > latest_time:
new_end = latest_time
return TimeRange(start, new_end)
def _getGaps(self, WEName, trList):
fullHazardInv = self._getWEInventory(WEName)
gaps = []
for timeRange in trList:
# Convert Java TimeRange to Python for comparisons
if not isinstance(timeRange, TimeRange):
timeRange = TimeRange(timeRange)
hazInv = []
for h in fullHazardInv:
if timeRange.overlaps(h):
hazInv.append(h)
# check for empty inventory
if len(hazInv) == 0: # no grids at all
gaps.append(timeRange)
continue
# see if we have a gap at the beginning
if timeRange.startTime() < hazInv[0].startTime():
tr = TimeRange(timeRange.startTime(),
hazInv[0].startTime())
gaps.append(tr)
# Find any gaps in the middle of the inventory
for i in range(len(hazInv) - 1):
if hazInv[i].endTime() != hazInv[i+1].startTime():
gapTR = TimeRange(hazInv[i].endTime(),
hazInv[i+1].startTime())
gaps.append(gapTR)
# see if we have a gap at the end of the inventory
if timeRange.endTime() > hazInv[-1].endTime():
tr = TimeRange(hazInv[-1].endTime(),
timeRange.endTime())
gaps.append(tr)
return gaps
def test_can_be_printed(self):
w = Week()
for i in xrange(7):
w.set_day(i, TimeRange(Time(7), Time(17)))
self.assertEquals(
str(w), """M: 7:00-17:00
T: 7:00-17:00
O: 7:00-17:00
T: 7:00-17:00
F: 7:00-17:00
L: 7:00-17:00
S: 7:00-17:00""")
def _setupHazardsInventory(self, weName, trList):
# see if the element exists yet, if not, make a new grid
# This is a painful way just to see if the grid exists
# but all other techniques fail for temporary weather elements
now = current()
yesterday = now - (24 * 3600) # one day ago
later = now + 10 * 24 * 3600 # 10 days from now
timeRange = TimeRange(yesterday, later).toJavaObj()
try:
gridInfo = self.getGridInfo(MODEL, weName, LEVEL, timeRange)
except: # this means the WE does not exist, so make a grid
if len(trList) <= 0:
return
for tr in trList:
self._makeEmptyHazardGrid(weName, tr)
return
# fill any gaps in the inventory
gapList = self._getGaps(weName, trList)
for g in gapList:
self._makeEmptyHazardGrid(weName, g)
# Split the grids at the timeRange boundaries
unix_now = now.unixTime()
for tr in trList:
# If tr is a java timerange, convert it to a python TimeRange
if not isinstance(tr, TimeRange):
tr = TimeRange(tr)
end = tr.endTime().unixTime()
if end > unix_now:
# parm.splitTR() will split timeRanges with non-zero minutes
# to the next hour. So, truncate start and end times to the
# previous hour and then split
start = tr.startTime().unixTime()
start = int(start / 3600) * 3600
end = int(end / 3600) * 3600
roundedTR = TimeRange(AbsTime(start), AbsTime(end)).toJavaObj()
parm = self.getParm(MODEL, weName, LEVEL)
self.splitCmd([weName], roundedTR)
return
def __init__(self,
first_name,
last_name,
email,
availability=[("07-01-2019 00:00", "07-02-2019 00:00")],
preferences=["improv", "sketch", "standup", "drama"]):
self.__first_name = first_name
self.__last_name = last_name
self.__email = email
self.__preferences = preferences
self.__availability = []
for time_range in availability:
self.__availability.append(TimeRange(time_range[0], time_range[1]))
def __init__(self, refTime=None, fcstTime=None, validPeriod=None):
self.fcstTime = int(fcstTime) if fcstTime is not None else 0
self.refTime = refTime if refTime is not None else None
if validPeriod is not None and type(validPeriod) is not TimeRange:
ValueError("Invalid validPeriod object specified for DataTime.")
self.validPeriod = validPeriod if validPeriod is not None else None
self.utilityFlags = EnumSet(
'com.raytheon.uf.common.time.DataTime$FLAG')
self.levelValue = numpy.float64(-1.0)
if self.refTime is not None:
if isinstance(self.refTime, datetime.datetime):
self.refTime = long(
calendar.timegm(self.refTime.utctimetuple()) * 1000)
elif isinstance(self.refTime, time.struct_time):
self.refTime = long(calendar.timegm(self.refTime) * 1000)
elif hasattr(self.refTime, 'getTime'):
# getTime should be returning ms, there is no way to check this
# This is expected for java Date
self.refTime = long(self.refTime.getTime())
else:
self.refTime = long(refTime)
self.refTime = Date(self.refTime)
if self.validPeriod is None:
validTimeMillis = self.refTime.getTime() + long(
self.fcstTime * 1000)
self.validPeriod = TimeRange()
self.validPeriod.setStart(validTimeMillis / 1000)
self.validPeriod.setEnd(validTimeMillis / 1000)
# figure out utility flags
if fcstTime:
self.utilityFlags.add("FCST_USED")
if self.validPeriod and self.validPeriod.isValid():
self.utilityFlags.add("PERIOD_USED")
def test_can_be_concatenated(self):
w1 = Week()
w2 = Week()
w1.set_day(0, TimeRange(Time(8, 30), Time(13, 30)))
w2.set_day(0, TimeRange(Time(13, 30), Time(17)))
w1.set_day(1, TimeRange(Time(7), Time(12)))
w2.set_day(2, TimeRange(Time(8), Time(13)))
w3 = w1 + w2
self.assertEquals(w3.get_day(0), TimeRange(Time(8, 30), Time(17)))
self.assertEquals(w3.get_day(1), TimeRange(Time(7), Time(12)))
self.assertEquals(w3.get_day(2), TimeRange(Time(8), Time(13)))
def test_generates_realistic_schedule(self):
taken_week = Week()
taken = [
TimeRange(Time(8, 30), Time(13, 30)),
TimeRange(Time(6, 30), Time(13, 30)),
TimeRange(Time(7), Time(17)),
TimeRange(Time(6, 30), Time(13, 30))
]
for i in xrange(len(taken)):
taken_week.set_day(i, taken[i])
week = generate_week(Hours(30, 20), taken_week)
ranges = [
TimeRange(Time(13, 30), Time(20)), # 23:50 left
TimeRange(Time(13, 30), Time(20)), # 17:20 left
TimeRange(Time(17), Time(20)), # 14:20 left
TimeRange(Time(13, 30), Time(20)), # 7:50 left
TimeRange(Time(7), Time(14, 50))
] # 0:00 left
for i in xrange(len(ranges)):
self.assertEquals(week.get_day(i), ranges[i])
def test_first_day_is_shorter_if_day_is_taken(self):
taken_week = Week()
taken_week.set_day(0, TimeRange(Time(7), Time(17)))
week = generate_week(Hours(40), taken_week)
ranges = [
TimeRange(Time(17), Time(20)),
TimeRange(Time(7), Time(17)),
TimeRange(Time(7), Time(17)),
TimeRange(Time(7), Time(17)),
TimeRange(Time(7), Time(14))
]
for i in xrange(5):
self.assertEquals(week.get_day(i), ranges[i])
def _getWEInventory(self, WEName, timeRange=None, asJava=False):
# set up a timeRange if it is None
if timeRange is None:
now = current()
yesterday = now - (24 * 3600) # one day ago
later = now + 10 * 24 * 3600 # 10 days from now
timeRange = self._makeTimeRange(yesterday.unixTime(), later.unixTime())
parm = self.getParm(MODEL, WEName, LEVEL)
trList = []
if parm is not None:
if isinstance(timeRange, JavaWrapperClass):
timeRange = timeRange.toJavaObj()
gridInventory = parm.getGridInventory(timeRange)
for g in gridInventory:
gridTimeRange = g.getGridTime()
tr = gridTimeRange.clone()
if not asJava:
tr = TimeRange(tr)
trList.append(tr)
return trList
def _lockHazards(self):
"Flag the hazards parm as being edited. Return the hazards parm and its grid."
hazParm = self.getParm(MODEL, ELEMENT, LEVEL)
startAbsTime = AbsTime(int(current().unixTime() /3600)*3600)
endAbsTime = startAbsTime + LOCK_HOURS() * HOUR_SECONDS()
timeRange = TimeRange(startAbsTime, endAbsTime)
inventory = self._getWEInventory(ELEMENT, timeRange, asJava=True)
startTimes = jep.jarray(len(inventory), Date)
for trNum in range(len(inventory)):
startTimes[trNum] = inventory[trNum].getStart()
gridData = None
try:
# startParmEdit() refreshes the grids and sets up the times that endParmEdit() will lock.
gridData = hazParm.startParmEdit(startTimes)
except RuntimeError, runtimeErr:
if runtimeErr.message is None:
raise
if runtimeErr.message.startswith("com.raytheon.viz.gfe.GFEOperationFailedException:"):
self.statusBarMsg("There are conflicting locks. " + \
"Please resolve these before adding any hazards", "S")
hazParm = None
else:
raise
class TimeRangeTest(unittest.TestCase):
def setUp(self):
self.time_range_1 = TimeRange("07-01-2019 10:00", "07-01-2019 20:00")
self.time_range_2 = TimeRange("07-01-2019 12:00", "07-01-2019 15:30")
self.time_range_3 = TimeRange("07-02-2019 10:00", "07-02-2019 15:30")
self.time_range_4 = TimeRange("07-01-2019 18:00", "07-01-2019 20:01")
def test_TimeRange_displays_start_time_string(self):
self.assertEqual(self.time_range_1.get_start_time_string(),
"07-01-2019 10:00")
self.assertEqual(self.time_range_2.get_start_time_string(),
"07-01-2019 12:00")
def test_TimeRange_displays_end_time_string(self):
self.assertEqual(self.time_range_3.get_end_time_string(),
"07-02-2019 15:30")
self.assertEqual(self.time_range_4.get_end_time_string(),
"07-01-2019 20:01")
def test_TimeRange_in_range_determines_if_daterange_in_range(self):
self.assertEqual(self.time_range_1.in_range(self.time_range_2), True)
self.assertEqual(self.time_range_1.in_range(self.time_range_3), False)
self.assertEqual(self.time_range_2.in_range(self.time_range_1), False)
self.assertEqual(self.time_range_1.in_range(self.time_range_4), False)
def _getGaps(self, WEName, trList):
fullHazardInv = self._getWEInventory(WEName)
gaps = []
for timeRange in trList:
# Convert Java TimeRange to Python for comparisons
if not isinstance(timeRange, TimeRange):
timeRange = TimeRange(timeRange)
hazInv = []
for h in fullHazardInv:
if timeRange.overlaps(h):
hazInv.append(h)
# check for empty inventory
if len(hazInv) == 0: # no grids at all
gaps.append(timeRange)
continue
# see if we have a gap at the beginning
if timeRange.startTime() < hazInv[0].startTime():
tr = TimeRange(timeRange.startTime(),
hazInv[0].startTime())
gaps.append(tr)
# Find any gaps in the middle of the inventory
for i in range(len(hazInv) - 1):
if hazInv[i].endTime() != hazInv[i+1].startTime():
gapTR = TimeRange(hazInv[i].endTime(),
hazInv[i+1].startTime())
gaps.append(gapTR)
# see if we have a gap at the end of the inventory
if timeRange.endTime() > hazInv[-1].endTime():
tr = TimeRange(hazInv[-1].endTime(),
timeRange.endTime())
gaps.append(tr)
return gaps
def _setupHazardsInventory(self, weName, trList):
# see if the element exists yet, if not, make a new grid
# This is a painful way just to see if the grid exists
# but all other techniques fail for temporary weather elements
now = current()
yesterday = now - (24 * 3600) # one day ago
later = now + 10 * 24 * 3600 # 10 days from now
timeRange = TimeRange(yesterday, later).toJavaObj()
try:
gridInfo = self.getGridInfo(MODEL, weName, LEVEL, timeRange)
except: # this means the WE does not exist, so make a grid
if len(trList) <= 0:
return
for tr in trList:
self._makeEmptyHazardGrid(weName, tr)
return
# fill any gaps in the inventory
gapList = self._getGaps(weName, trList)
for g in gapList:
self._makeEmptyHazardGrid(weName, g)
# Split the grids at the timeRange boundaries
unix_now = now.unixTime()
for tr in trList:
# If tr is a java timerange, convert it to a python TimeRange
if not isinstance(tr, TimeRange):
tr = TimeRange(tr)
end = tr.endTime().unixTime()
if end > unix_now:
# parm.splitTR() will split timeRanges with non-zero minutes
# to the next hour. So, truncate start and end times to the
# previous hour and then split
start = tr.startTime().unixTime()
start = int(start / 3600) * 3600
end = int(end / 3600) * 3600
roundedTR = TimeRange(AbsTime(start), AbsTime(end)).toJavaObj()
parm = self.getParm(MODEL, weName, LEVEL)
self.splitCmd([weName], roundedTR)
return
def test_can_be_empty(self):
time_range = TimeRange()
self.assertEquals(time_range.get_length(), Hours(0))
def _addHazard(self, weName, timeRange, addHaz, mask, combine=1):
# Python TimeRanges are easy to compare.
# Java methods require Java TimeRanges.
# Make sure we have one of each.
if isinstance(timeRange, JavaWrapperClass):
pyTimeRange = timeRange
timeRange = timeRange.toJavaObj()
else:
pyTimeRange = TimeRange(timeRange)
# refuse to make new grids that are more than one hour in the past
if pyTimeRange.endTime().unixTime() < current().unixTime() - HOUR_SECONDS():
msg = "skipped time range creation: %s < %s" % (pyTimeRange.endTime().string(), current().string())
return
# set up the inventory first
self._setupHazardsInventory(weName, [timeRange])
# get the inventory
trList = self._getWEInventory(weName, timeRange, asJava=True)
# coerce mask into a boolean array if it isn't already
if not (isinstance(mask, numpy.ndarray) and mask.dtype==numpy.bool):
mask = numpy.array(mask, dtype=numpy.bool)
for tr in trList:
# get the grid of index values and list of keys those indices select
byteGrid, hazKey = self.getGrids(MODEL, weName, LEVEL, tr,
mode="First", cache=0)
if isinstance(hazKey, str):
hazKey = eval(hazKey)
# Eliminate keys that aren't in the grid from the list.
uniqueKeys = self._getUniqueKeys(byteGrid, hazKey, mask)
for uKey in uniqueKeys:
# Figure out what the new key is
if combine:
newKey = self._makeNewKey(uKey, addHaz)
else: #replace
newKey = addHaz
# Find the index number for the old key
oldIndex = self.getIndex(uKey, hazKey)
# Find the index number for the new key (newKey is added if not in hazKey)
newIndex = self.getIndex(newKey, hazKey)
# calculate the mask - intersection of mask and oldIndex values
editMask = (byteGrid==oldIndex) & mask
# poke in the new values
byteGrid[editMask] = newIndex
# Save the updated byteGrid and hazKey
if weName == ELEMENT:
self.createGrid(MODEL, ELEMENT, "DISCRETE", (byteGrid, hazKey),
tr, discreteOverlap=1, discreteAuxDataLength=4)
else: # it's a temporary WE - special key
hazKey = ["<None>", addHaz]
hazKeyDesc = self._addHazardDesc(hazKey)
self.createGrid(MODEL, weName, "DISCRETE", (byteGrid, hazKey),
tr, discreteOverlap=0, discreteAuxDataLength=4,
discreteKeys=hazKeyDesc,
defaultColorTable="YesNo")
# remove any grids that are completely in the past
self._removeOldGrids(weName)
return
def testAbsTimeZero():
start = AbsTime(0)
end = current()
timeRange = TimeRange(start, end)
javaTR = timeRange.toJavaObj()
return javaTR
def _separateHazardGrids(self):
"Make temporary hazard grids for each hazard subkey."
# if any temp hazard grids are loaded, don't separate again
if self._tempWELoaded():
return FAIL_REDUNDANT #already separated
hazParm, gridData = self._lockHazards()
if hazParm is None:
return FAIL_LOCK # unavailable
# get a collection of distinct Java TimeRange objects
trSet = set()
for gd in gridData:
trSet.add(gd.getGridTime())
# Create a set of temporary weather element names
weNameSet = set()
for tr in trSet:
# Get the index grid and key list for the real Hazards element
byteGrid, hazKey = self.getGrids(MODEL, ELEMENT, LEVEL, tr,
mode="First")
if isinstance(hazKey, str):
hazKey = eval(hazKey)
# Only work with the keys that have points in the grid
uniqueKeys = self._getUniqueKeys(byteGrid, hazKey)
if len(uniqueKeys) > 0:
# build list of split hazKeys for use in loop below
splitHazKeys = []
for haz in hazKey:
splitHazKeys.append(self._getSubKeys(haz))
for uKey in uniqueKeys:
if uKey == "<None>":
continue
# split the current key into its subkeys
subKeys = self._getSubKeys(uKey)
for subKey in subKeys:
# make the temporary name
weName = self._makeTempWEName(subKey)
# make the mask - find all areas that contain the subKey
mask = numpy.zeros(byteGrid.shape, dtype='bool')
for hazIndex in range(len(hazKey)):
if subKey in splitHazKeys[hazIndex]:
mask |= (byteGrid==hazIndex)
# make the grid
self._addHazard(weName, tr, subKey, mask)
pytr = TimeRange(tr)
logmsg = " ".join(["Separate", weName,
self._printTime(pytr.startTime().unixTime()),
self._printTime(pytr.endTime().unixTime()), subKey])
LogStream.logEvent(logmsg)
# save the weNames for later
weNameSet.add(weName)
# Combine time ranges for the temporary weather elements we created
self._consolidateTimes(weNameSet)
return SUCCESS
def _separateHazardGrids(self):
"Make temporary hazard grids for each hazard subkey."
# if any temp hazard grids are loaded, don't separate again
if self._tempWELoaded():
return FAIL_REDUNDANT #already separated
hazParm, gridData = self._lockHazards()
if hazParm is None:
return FAIL_LOCK # unavailable
# get a collection of distinct Java TimeRange objects
trSet = set()
for gd in gridData:
trSet.add(gd.getGridTime())
# Create a set of temporary weather element names
weNameSet = set()
for tr in trSet:
# Get the index grid and key list for the real Hazards element
byteGrid, hazKey = self.getGrids(MODEL, ELEMENT, LEVEL, tr,
mode="First")
if isinstance(hazKey, str):
hazKey = eval(hazKey)
# Only work with the keys that have points in the grid
uniqueKeys = self._getUniqueKeys(byteGrid, hazKey)
if len(uniqueKeys) > 0:
# build list of split hazKeys for use in loop below
splitHazKeys = []
for haz in hazKey:
splitHazKeys.append(self._getSubKeys(haz))
for uKey in uniqueKeys:
if uKey == "<None>":
continue
# split the current key into its subkeys
subKeys = self._getSubKeys(uKey)
for subKey in subKeys:
# make the temporary name
weName = self._makeTempWEName(subKey)
# make the mask - find all areas that contain the subKey
mask = numpy.zeros(byteGrid.shape, dtype=numpy.bool)
for hazIndex in range(len(hazKey)):
if subKey in splitHazKeys[hazIndex]:
mask |= (byteGrid==hazIndex)
# make the grid
self._addHazard(weName, tr, subKey, mask)
pytr = TimeRange(tr)
logmsg = " ".join(["Separate", weName,
self._printTime(pytr.startTime().unixTime()),
self._printTime(pytr.endTime().unixTime()), subKey])
LogStream.logEvent(logmsg)
# save the weNames for later
weNameSet.add(weName)
# Combine time ranges for the temporary weather elements we created
self._consolidateTimes(weNameSet)
return SUCCESS
def test_simple_range_from_9_to_17_is_8_hours(self):
time_range = TimeRange(Time(9, 0), Time(17, 0))
self.assertEquals(time_range.get_length(), Hours(8))
def test_can_give_length_for_9_to_10_30(self):
time_range = TimeRange(Time(9), Time(10, 30))
self.assertEquals(time_range.get_length(), Hours(1, 30))
class DataTime(object):
def __init__(self, refTime=None, fcstTime=None, validPeriod=None):
self.fcstTime = int(fcstTime) if fcstTime is not None else 0
self.refTime = refTime if refTime is not None else None
if validPeriod is not None and type(validPeriod) is not TimeRange:
ValueError("Invalid validPeriod object specified for DataTime.")
self.validPeriod = validPeriod if validPeriod is not None else None
self.utilityFlags = EnumSet('com.raytheon.uf.common.time.DataTime$FLAG')
self.levelValue = numpy.float64(-1.0)
if self.refTime is not None:
if isinstance(self.refTime, datetime.datetime):
self.refTime = long(calendar.timegm(self.refTime.utctimetuple()) * 1000)
elif isinstance(self.refTime, time.struct_time):
self.refTime = long(calendar.timegm(self.refTime) * 1000)
elif hasattr(self.refTime, 'getTime'):
# getTime should be returning ms, there is no way to check this
# This is expected for java Date
self.refTime = long(self.refTime.getTime())
else:
self.refTime = long(refTime)
self.refTime = Date(self.refTime)
if self.validPeriod is None:
validTimeMillis = self.refTime.getTime() + long(self.fcstTime * 1000)
self.validPeriod = TimeRange()
self.validPeriod.setStart(validTimeMillis / 1000)
self.validPeriod.setEnd(validTimeMillis / 1000)
# figure out utility flags
if fcstTime:
self.utilityFlags.add("FCST_USED")
if self.validPeriod and self.validPeriod.isValid():
self.utilityFlags.add("PERIOD_USED")
def getRefTime(self):
return self.refTime
def setRefTime(self, refTime):
self.refTime = refTime
def getFcstTime(self):
return self.fcstTime
def setFcstTime(self, fcstTime):
self.fcstTime = fcstTime
def getValidPeriod(self):
return self.validPeriod
def setValidPeriod(self, validPeriod):
self.validPeriod = validPeriod
def getUtilityFlags(self):
return self.utilityFlags
def setUtilityFlags(self, utilityFlags):
self.utilityFlags = utilityFlags
def getLevelValue(self):
return self.levelValue
def setLevelValue(self, levelValue):
self.levelValue = numpy.float64(levelValue)
def __str__(self):
buffer = StringIO.StringIO()
if self.refTime is not None:
refTimeInSecs = self.refTime.getTime() / 1000
micros = (self.refTime.getTime() % 1000) * 1000
dtObj = datetime.datetime.utcfromtimestamp(refTimeInSecs)
dtObj = dtObj.replace(microsecond=micros)
buffer.write(dtObj.isoformat(' '))
if "FCST_USED" in self.utilityFlags:
hrs = int(self.fcstTime / 3600)
mins = int((self.fcstTime - (hrs * 3600)) / 60)
buffer.write(" (" + str(hrs))
if mins != 0:
buffer.write(":" + str(mins))
buffer.write(")")
if "PERIOD_USED" in self.utilityFlags:
buffer.write("[")
buffer.write(self.validPeriod.start.isoformat(' '))
buffer.write("--")
buffer.write(self.validPeriod.end.isoformat(' '))
buffer.write("]")
strVal = buffer.getvalue()
buffer.close()
return strVal
def __repr__(self):
return "<DataTime instance: " + str(self) + " >"
def __hash__(self):
hashCode = hash(self.refTime) ^ hash(self.fcstTime)
if self.validPeriod is not None and self.validPeriod.isValid():
hashCode ^= hash(self.validPeriod.getStart())
hashCode ^= hash(self.validPeriod.getEnd())
hashCode ^= hash(self.levelValue)
return hashCode
def __eq__(self, other):
if type(self) != type(other):
return False
if other.getRefTime() is None:
return self.fcstTime == other.fcstTime
dataTime1 = (self.refTime, self.fcstTime, self.validPeriod, self.levelValue)
dataTime2 = (other.refTime, other.fcstTime, other.validPeriod, other.levelValue)
return dataTime1 == dataTime2
def __ne__(self, other):
return not self.__eq__(other)
def __lt__(self, other):
if type(self) != type(other):
return NotImplemented
myValidTime = self.getRefTime().getTime() + self.getFcstTime()
otherValidTime = other.getRefTime().getTime() + other.getFcstTime()
if myValidTime < otherValidTime:
return True
if self.fcstTime < other.fcstTime:
return True
if self.levelValue < other.levelValue:
return True
myValidPeriod = self.validPeriod
otherValidPeriod = other.validPeriod
if myValidPeriod != otherValidPeriod:
if myValidPeriod.duration() < otherValidPeriod.duration():
return True
return myValidPeriod.getStartInMillis() < otherValidPeriod.getStartInMillis()
return False
def __le__(self, other):
if type(self) != type(other):
return NotImplemented
return self.__lt__(other) or self.__eq__(other)
def __gt__(self, other):
if type(self) != type(other):
return NotImplemented
myValidTime = self.getRefTime().getTime() + self.getFcstTime()
otherValidTime = other.getRefTime().getTime() + other.getFcstTime()
if myValidTime > otherValidTime:
return True
if self.fcstTime > other.fcstTime:
return True
if self.levelValue > other.levelValue:
return True
myValidPeriod = self.validPeriod
otherValidPeriod = other.validPeriod
if myValidPeriod != otherValidPeriod:
if myValidPeriod.duration() > otherValidPeriod.duration():
return True
return myValidPeriod.getStartInMillis() > otherValidPeriod.getStartInMillis()
return False
def __ge__(self, other):
if type(self) != type(other):
return NotImplemented
return self.__gt__(other) or self.__eq__(other)
def test_can_return_end_time(self):
time_range = TimeRange(Time(9), Time(10))
self.assertEquals(time_range.get_end(), Time(10))
def setUp(self):
self.time_range_1 = TimeRange("07-01-2019 10:00", "07-01-2019 20:00")
self.time_range_2 = TimeRange("07-01-2019 12:00", "07-01-2019 15:30")
self.time_range_3 = TimeRange("07-02-2019 10:00", "07-02-2019 15:30")
self.time_range_4 = TimeRange("07-01-2019 18:00", "07-01-2019 20:01")
def _addHazard(self, weName, timeRange, addHaz, mask, combine=1):
# Python TimeRanges are easy to compare.
# Java methods require Java TimeRanges.
# Make sure we have one of each.
if isinstance(timeRange, JavaWrapperClass):
pyTimeRange = timeRange
timeRange = timeRange.toJavaObj()
else:
pyTimeRange = TimeRange(timeRange)
# refuse to make new grids that are more than one hour in the past
if pyTimeRange.endTime().unixTime() < current().unixTime() - HOUR_SECONDS():
msg = "skipped time range creation: %s < %s" % (pyTimeRange.endTime().string(), current().string())
return
# set up the inventory first
self._setupHazardsInventory(weName, [timeRange])
# get the inventory
trList = self._getWEInventory(weName, timeRange, asJava=True)
# coerce mask into a boolean array if it isn't already
if not (isinstance(mask, numpy.ndarray) and mask.dtype==numpy.bool):
mask = numpy.array(mask, dtype=numpy.bool)
for tr in trList:
# get the grid of index values and list of keys those indices select
byteGrid, hazKey = self.getGrids(MODEL, weName, LEVEL, tr,
mode="First", cache=0)
if isinstance(hazKey, str):
hazKey = eval(hazKey)
# Eliminate keys that aren't in the grid from the list.
uniqueKeys = self._getUniqueKeys(byteGrid, hazKey, mask)
for uKey in uniqueKeys:
# Figure out what the new key is
if combine:
newKey = self._makeNewKey(uKey, addHaz)
else: #replace
newKey = addHaz
# Find the index number for the old key
oldIndex = self.getIndex(uKey, hazKey)
# Find the index number for the new key (newKey is added if not in hazKey)
newIndex = self.getIndex(newKey, hazKey)
# calculate the mask - intersection of mask and oldIndex values
editMask = (byteGrid==oldIndex) & mask
# poke in the new values
byteGrid[editMask] = newIndex
# Save the updated byteGrid and hazKey
if weName == ELEMENT:
self.createGrid(MODEL, ELEMENT, "DISCRETE", (byteGrid, hazKey),
tr, discreteOverlap=1, discreteAuxDataLength=4)
else: # it's a temporary WE - special key
hazKey = ["<None>", addHaz]
hazKeyDesc = self._addHazardDesc(hazKey)
self.createGrid(MODEL, weName, "DISCRETE", (byteGrid, hazKey),
tr, discreteOverlap=0, discreteAuxDataLength=4,
discreteKeys=hazKeyDesc,
defaultColorTable="YesNo")
# remove any grids that are completely in the past
self._removeOldGrids(weName)
return
