def test_dtrange_stop_n(self):
start = datetime(2000, 1, 1)
stop = datetime(2001, 1, 1)
n = 10
for ctr, it in enumerate(dtrange(start, stop, n=n, endpoint=False)):
pass
self.assertEqual(n, ctr+1)
self.assertTrue(it < stop)
for ctr, it in enumerate(dtrange(start, stop, n=n, endpoint=True)):
pass
self.assertEqual(n, ctr+1)
self.assertEqual(stop, it)
def __init__(self, start, stop=None, step=None, n=None, units='s',
endpoint=False):
'''
Parameters
----------
start : time
First inclusive time.
stop : time, optional
Optional. Inclusive if closed=True.
step : timedelta or number, optional
Requires units if is a number.
n : number, optional
Number of divisions between start and stop.
units : str, optional
h=hour, m=minute, s=second, ms=millisec, us=microsec
Default is 's'.
endpoint : bool, optional
If true, then stop is included, otherwise use half-open bounds.
Default is False.
'''
start = datetime_from_time(start)
if stop:
stop = datetime_from_time(stop)
self.dtrange = dtrange(start, stop=stop, step=step, n=n, units=units,
endpoint=endpoint)
def test_dtrange_stop_step_units_month(self):
start = datetime(2000, 1, 1)
stop = datetime(2002, 1, 1)
for it in dtrange(start, stop, step=1, units='m', endpoint=1):
pass
self.assertEqual(stop, it)
def test_dtrange_stop_step_units_year(self):
start = datetime(2000, 1, 1)
stop = datetime(2020, 1, 1)
for it in dtrange(start, stop, step=1, units='y'):
pass
expect = datetime(2019, 1, 1)
self.assertEqual(expect, it)
def test_dtrange_step_n(self):
start = datetime(2000, 1, 1)
step = timedelta(1)
for it in dtrange(start, step=step, n=31):
pass
expect = datetime(2000, 1, 31)
self.assertEqual(expect, it)
def test_dtrange_stop_step_endpoint(self):
start = datetime(2000, 1, 1)
stop = datetime(2000, 2, 1)
step = timedelta(1)
for it in dtrange(start, stop, step, endpoint=True):
pass
expect = datetime(2000, 2, 1)
self.assertEqual(expect, it)
def test_dtrange_step_n_units(self):
start = datetime(2000, 1, 1)
n = 10
for units in ['y', 'm', 'w', 'd', 'h', 'min', 's', 'ms', 'us']:
for ctr, it in enumerate(dtrange(start, step=1, n=n, units=units)):
pass
self.assertTrue(it > start)
self.assertEqual(n, ctr + 1)
def test_dtrange_stop_step_units(self):
start = datetime(2000, 1, 1)
stop = datetime(2000, 2, 1)
for units in ['w', 'd']:
for it in dtrange(start, stop, step=1, units=units, endpoint=True):
pass
self.assertEqual(stop, it)
stop = datetime(2000, 1, 2)
for units in ['h', 'min', 's']:
for it in dtrange(start, stop, step=1, units=units, endpoint=True):
pass
self.assertEqual(stop, it)
stop = datetime(2000, 1, 1, 0, 0, 0, 10)
for units in ['ms', 'us']:
for it in dtrange(start, stop, step=1, units=units, endpoint=True):
pass
self.assertEqual(stop, it)
def _chop_date_range_into_days(datetime_begin, datetime_end):
"""
Returns a range of days (datetimes) that are fully within the given date range.
:param datetime_begin: a datetime object that indicates the inclusive lower bound of the desired date-range
:param datetime_end: a datetime object that indicates the exclusive upper bound of the desired date-range
:return: An ordered list of datetime objects containing the days that are fully within the given range,
as well as a tuple containing whether the left part and the right part of the date range have been consumed completely.
"""
if datetime_begin > datetime_end:
raise ValueError("date_begin cannot be larger than date_end")
range_begin = datetime(datetime_begin.year, datetime_begin.month, datetime_begin.day)
range_end = datetime(datetime_end.year, datetime_end.month, datetime_end.day)
complete_l = True
complete_r = True
if datetime_begin.hour != 0 or datetime_begin.minute != 0:
range_begin += timedelta(1)
complete_l = False
if datetime_end.hour != 0 or datetime_end.minute != 0:
complete_r = False
return [day for day in dtrange(range_begin, range_end, step=1, units='d')], (complete_l, complete_r)
def test_dtrange_bad_args(self):
raised = False
try: dtrange(datetime(1,1,1))
except: raised = True
self.assertTrue(raised)
raised = False
try: dtrange(datetime(1,1,1), stop=datetime(2,2,2))
except: raised = True
self.assertTrue(raised)
raised = False
try: dtrange(datetime(1,1,1), units='y', n=10)
except: raised = True
self.assertTrue(raised)
def __call__(self,
varName,
sDTime,
eDTime,
BBox=None,
res=None,
delT=None):
'''
res : spa. res. of 2d-array
sDTime : DTime bound left
eDTime : DTime bound right
'''
mapCode = '^' + ''.join(str(res).split('.'))
gpmData = GPM_data()
srcDir = os.path.join(self.dataDir, self.prdDir)
assert os.path.exists(srcDir), '{} is not exists.'.format(srcDir)
Granule = self.search_granules(srcDir, sDTime, eDTime, BBox)
if len(Granule) == 0:
print('! Warning ! no data extracted')
return None
outSize = sum([len(gra[2]) for gra in Granule]), Granule[0][2].shape[1]
Lat = empty(outSize, 'float32')
Lon = empty(outSize, 'float32')
aOut = empty(outSize, 'float32')
DTime = []
prvI = 0
for granule in Granule:
srcPath, dtime, lat, lon, idx = granule
gpmData.srcPath.append(srcPath)
gpmData.recLen.append(
len(dtime)) # number of data record for each file
nxtI = prvI + len(dtime)
aOut[prvI:nxtI] = self.func_read(srcPath, varName, idx.tolist())
Lat[prvI:nxtI] = lat
Lon[prvI:nxtI] = lon
DTime.extend(dtime)
if res != None and delT == None:
gpmData.griddata.append(
granule2map(lat, lon, aOut[prvI:nxtI], BBox, res))
gpmData.grid = GridCoordinates(mapCode, BBox=BBox)
prvI = nxtI
if delT != None:
dtBnd = dtrange(sDTime, eDTime, delT)
gpmData.tbound = map(None, dtBnd[:-1], dtBnd[1:])
gpmData.dtime = bin_bytbound(DTime, dtBnd, DTime)
gpmData.lat = bin_bytbound(DTime, dtBnd, Lat)
gpmData.lon = bin_bytbound(DTime, dtBnd, Lon)
gpmData.data = bin_bytbound(DTime, dtBnd, aOut)
if res != None:
gpmData.griddata = [
granule2map(lat, lon, a, BBox, res) for lat, lon, a in map(
None, gpmData.lat, gpmData.lon, gpmData.data)
]
gpmData.grid = GridCoordinates(mapCode, BBox=BBox)
else:
gpmData.dtime = DTime
gpmData.lat = Lat
gpmData.lon = Lon
gpmData.data = aOut
return gpmData
