import numpy as np from numpy import * @test def test_compare_generic_nat(): # regression tests for gh-6452 assert np.datetime64('NaT') != (np.datetime64('2000') + np.timedelta64('NaT')) assert np.datetime64('NaT') != np.datetime64('NaT', 'us') assert np.datetime64('NaT', 'us') != np.datetime64('NaT') test_compare_generic_nat() @test def test_datetime_nat_argsort_stability(): # NaT < NaT should be False internally for sort stability sizes = [3, 21, 217, 1000] for size in sizes: expected = np.arange(size) arr = np.tile(np.datetime64('NaT'), size) assert array_equal(np.argsort(arr, kind='mergesort'), expected) test_datetime_nat_argsort_stability() def test_datetime_maximum_reduce(): a = np.array(['2010-01-02', '1999-03-14', '1833-03'], np.datetime64['D', 1]) assert isinstance(np.maximum.reduce(a), np.datetime64['D', 1]) assert np.maximum.reduce(a) == np.datetime64('2010-01-02') a = np.array([1, 4, 0, 7, 2], np.timedelta64['s', 1]) assert isinstance(np.maximum.reduce(a), np.timedelta64['s', 1]) assert np.maximum.reduce(a) == np.timedelta64(7, 's') test_datetime_maximum_reduce() @test def test_timedelta_nat_argsort_stability(): # NaT < NaT should be False internally for sort stability sizes = [3, 21, 217, 1000] for size in sizes: expected = np.arange(size) arr = np.tile(np.timedelta64('NaT'), size) assert array_equal(np.argsort(arr, kind='mergesort'), expected) test_timedelta_nat_argsort_stability() @test def test_datetime_timedelta_sort_nat(): arr = ( # the example provided in gh-12629 ('NaT', 1, 2, 3), ( 'NaT', 1, -2, 3, )) expected = ((1, 2, 3, 'NaT'), (-2, 1, 3, 'NaT')) dtypes = ['M8[ns]', 'M8[us]'] for i in range(2): arr1 = np.array(arr[i], dtype=dtypes[i]) expect = np.array(expected[i], dtype=dtypes[i]) arr1.sort() assert array_equal(arr1, expect) test_datetime_timedelta_sort_nat() @test def test_datetime_scalar_construction(): # Construct with different units assert np.datetime64('1950-03-12', 'D') == np.datetime64('1950-03-12') assert np.datetime64('1950-03-12T13', 's') == np.datetime64('1950-03-12T13', 'm') # Default construction means NaT # TODO: Datetme64 currently does not have default constructor. # assert array_equal(np.datetime64(), np.datetime64('NaT')) # Some basic strings and repr assert str(np.datetime64('NaT')) == 'NaT' assert repr(np.datetime64('NaT')) == "numpy.datetime64('NaT', 'us')" assert str(np.datetime64('2011-02')) == '2011-02-01T00:00:00.000000' assert repr(np.datetime64( '2011-02')) == "numpy.datetime64('2011-02-01T00:00:00.000000', 'us')" # Construction with time units from a date is okay assert np.datetime64('1920-03-13', 'h') == np.datetime64('1920-03-13T00') assert np.datetime64('1920-03', 'm') == np.datetime64('1920-03-01T00:00') assert np.datetime64('1920', 's') == np.datetime64('1920-01-01T00:00:00') assert np.datetime64(datetime.date(2045, 3, 25), 'ms') == np.datetime64('2045-03-25T00:00:00.000') # Construction with date units from a datetime is also okay assert np.datetime64('1920-03-13T18', 'D') == np.datetime64('1920-03-13') assert np.datetime64('1920-03-13T18:33:12', 'M') == np.datetime64('1920-03') assert np.datetime64('1920-03-13T18:33:12.5', 'Y') == np.datetime64('1920') # None gets constructed as NaT # TODO: Datetme64 currently does not work without None parameter as well. # assert np.datetime64(None) == np.datetime64('NaT') # Default construction of NaT is in generic units # TODO: Datetme64 currently does not have default constructor. # assert np.datetime64().dtype == dtype = 'M8' assert isinstance(np.datetime64('NaT', 'h'), np.datetime64['h', 1]) # When constructing from a scalar or zero-dimensional array, # it either keeps the units or you can override them. a = np.datetime64('2000-03-18T16', 'h') b = np.array('2000-03-18T16', dtype=np.datetime64['h', 1]) assert isinstance(a, np.datetime64['h', 1]) assert isinstance(b.dtype, np.datetime64['h', 1]) assert isinstance(np.datetime64(a, 'h'), np.datetime64['h', 1]) assert np.datetime64(a, 'h') == a assert b == a # assert isinstance(np.datetime64(b, 'h'), np.datetime64['h',1]) # print(np.datetime64(b, 'h')) assert np.datetime64(a, 's') == a assert isinstance(np.datetime64(a, 's'), np.datetime64['s', 1]) # assert array_equal(np.datetime64(b, 's'), a) # assert array_equal(np.datetime64(b, 's').dtype, dtype='M8[s]') # Construction from datetime.date assert np.datetime64('1945-03-25') == np.datetime64( datetime.date(1945, 3, 25)) assert np.datetime64('2045-03-25', 'D') == np.datetime64(datetime.date(2045, 3, 25), 'D') # Construction from datetime.datetime assert np.datetime64('1980-01-25T14:36:22.5') == np.datetime64( datetime.datetime(1980, 1, 25, 14, 36, 22, 500000)) # Construction with time units from a date is okay assert np.datetime64('1920-03-13', 'h') == np.datetime64('1920-03-13T00', 'h') assert np.datetime64('1920-03', 'm') == np.datetime64('1920-03-01T00:00', 'm') assert np.datetime64('1920', 's') == np.datetime64('1920-01-01T00:00:00', 's') assert np.datetime64(datetime.date(2045, 3, 25), 'ms') == np.datetime64('2045-03-25T00:00:00.000', 'ms') # Construction with date units from a datetime is also okay assert np.datetime64('1920-03-13T18', 'D') == np.datetime64('1920-03-13', 'D') assert np.datetime64('1920-03-13T18:33:12', 'M') == np.datetime64('1920-03', 'M') assert np.datetime64('1920-03-13T18:33:12.5', 'Y') == np.datetime64('1920', 'Y') test_datetime_scalar_construction() @test def test_timedelta_np_int_construction(): assert np.timedelta64(np.int64(123), "Y") == np.timedelta64(123, "Y") assert np.timedelta64(np.int64(123), "M") == np.timedelta64(123, "M") assert np.timedelta64(np.int64(123), "W") == np.timedelta64(123, "W") assert np.timedelta64(np.int64(123), "D") == np.timedelta64(123, "D") assert np.timedelta64(np.int64(123), "h") == np.timedelta64(123, "h") assert np.timedelta64(np.int64(123), "m") == np.timedelta64(123, "m") assert np.timedelta64(np.int64(123), "s") == np.timedelta64(123, "s") assert np.timedelta64(np.int64(123), "ms") == np.timedelta64(123, "ms") assert np.timedelta64(np.int64(123), "us") == np.timedelta64(123, "us") assert np.timedelta64(np.int64(123), "ns") == np.timedelta64(123, "ns") assert np.timedelta64(np.int64(123), "ps") == np.timedelta64(123, "ps") assert np.timedelta64(np.int64(123), "fs") == np.timedelta64(123, "fs") assert np.timedelta64(np.int64(123), "as") == np.timedelta64(123, "as") test_timedelta_np_int_construction() @test() def test_timedelta_scalar_construction(): # Construct with different units assert np.timedelta64(7, 'D') == np.timedelta64(1, 'W') assert np.timedelta64(120, 's') == np.timedelta64(2, 'm') # Default construction means 0 # TODO: Timedelta64 currently does not have default constructor. # assert np.timedelta64() == np.timedelta64(0) # None gets constructed as NaT # assert np.timedelta64(None) == np.timedelta64('NaT') # Some basic strings and repr assert str(np.timedelta64('NaT')) == 'NaT' assert repr(np.timedelta64('NaT')) == "numpy.timedelta64(NaT, 'generic')" assert str(np.timedelta64(3, 's')) == '3 seconds' assert repr(np.timedelta64(-3, 's')) == "numpy.timedelta64(-3)" assert repr(np.timedelta64(12, 's')) == "numpy.timedelta64(12)" # Construction from an integer produces generic units assert isinstance(np.timedelta64(12, 'h'), np.timedelta64['h', 1]) # When constructing from a scalar or zero-dimensional array, # it either keeps the units or you can override them. a = np.timedelta64(2, 'h') b = np.array(2, dtype=np.timedelta64['h', 1]) assert isinstance(a, np.timedelta64['h', 1]) assert isinstance(b.dtype, np.timedelta64['h', 1]) assert np.timedelta64(a, 'h') == a assert isinstance(a, np.timedelta64['h', 1]) assert isinstance(b.dtype, np.timedelta64['h', 1]) assert isinstance(np.timedelta64(a, 'h'), np.timedelta64['h', 1]) assert np.timedelta64(a, 's') == a assert isinstance(np.timedelta64(a, 's'), np.timedelta64['s', 1]) # Construction from datetime.timedelta assert np.timedelta64(5, 'D') == np.timedelta64(datetime.timedelta(days=5)) assert np.timedelta64(102347621, 's') == np.timedelta64( datetime.timedelta(seconds=102347621)) assert np.timedelta64(-10234760000, 'us') == np.timedelta64( datetime.timedelta(microseconds=-10234760000)) assert np.timedelta64(10234760000, 'us') == np.timedelta64( datetime.timedelta(microseconds=10234760000)) assert np.timedelta64(1023476, 'ms') == np.timedelta64( datetime.timedelta(milliseconds=1023476)) assert np.timedelta64(10, 'm') == np.timedelta64( datetime.timedelta(minutes=10)) assert np.timedelta64(281, 'h') == np.timedelta64(datetime.timedelta(hours=281)) assert np.timedelta64(28, 'W') == np.timedelta64(datetime.timedelta(weeks=28)) test_timedelta_scalar_construction() @test() def test_timedelta_array_str(): a = np.array([-1, 0, 100], dtype='m') assert np.array_equal(a, np.array(['-1', '0', '100'])) a = np.array(['NaT', 'NaT'], dtype='m') assert np.array_equal(a, np.array(['NaT', 'NaT'])) # Check right-alignment with NaTs a = np.array(('NaT', -1, 0), dtype='m') assert np.array_equal(a, np.array(['NaT', '-1', '0'])) test_timedelta_array_str() @test def test_datetime_array_find_type(): dt = np.datetime64('1970-01-01', 'M') arr = np.array([dt]) assert isinstance(arr.dtype, np.datetime64['M', 1]) test_datetime_array_find_type() @test def test_datetime_nat_casting(): a = np.array('NaT', dtype='M8[D]') b = np.datetime64('NaT', 'D') assert np.isnat(a.astype(np.datetime64['s', 1]), np.array('NaT', np.datetime64['s', 1])) assert np.isnat(a.astype(np.datetime64['ms', 1]), np.array('NaT', np.datetime64['ms', 1])) assert np.isnat(a.astype(np.datetime64['M', 1]), np.array('NaT', np.datetime64['M', 1])) assert np.isnat(a.astype(np.datetime64['Y', 1]), np.array('NaT', np.datetime64['Y', 1])) assert np.isnat(a.astype(np.datetime64['W', 1]), np.array('NaT', np.datetime64['W', 1])) # Scalars -> Scalars assert np.isnat(np.datetime64(b, 's')) assert np.isnat(np.datetime64(b, 'ms')) assert np.isnat(np.datetime64(b, 'M')) assert np.isnat(np.datetime64(b, 'Y')) assert np.isnat(np.datetime64(b, 'W')) # Arrays -> Scalars # assert np.datetime64(a, 's') == np.datetime64('NaT', 's') # assert np.datetime64(a, 'ms]') == np.datetime64('NaT', 'ms') # assert np.datetime64(a, 'M') == np.datetime64('NaT', 'M') # assert np.datetime64(a, 'Y') == np.datetime64('NaT', 'Y') # assert np.datetime64(a, 'W') == np.datetime64('NaT', 'W') nan = np.array((np.nan, ) * 8 + (0, )) fnan = nan.astype(np.float32) lnan = nan.astype(np.float128) cnan = nan.astype(complex) cfnan = nan.astype(np.complex64) clnan = nan.astype(np.complex128) nat = np.array([np.datetime64('NaT')] * 8 + [np.datetime64(0, 'us')]) assert np.array_equal(nan.astype(np.datetime64['ns', 1]), nat, equal_nan=True) assert np.array_equal(fnan.astype(np.datetime64['ns', 1]), nat, equal_nan=True) assert np.array_equal(cnan.astype(np.datetime64['ns', 1]), nat, equal_nan=True) assert np.array_equal(cfnan.astype(np.datetime64['ns', 1]), nat, equal_nan=True) assert np.array_equal(clnan.astype(np.datetime64['ns', 1]), nat, equal_nan=True) nat = np.array([np.timedelta64('NaT', 'us')] * 8 + [np.timedelta64(0, 'us')]) assert np.array_equal(nan.astype(np.timedelta64['ns', 1]), nat, equal_nan=True) assert np.array_equal(fnan.astype(np.timedelta64['ns', 1]), nat, equal_nan=True) assert np.array_equal(cnan.astype(np.timedelta64['ns', 1]), nat, equal_nan=True) assert np.array_equal(cfnan.astype(np.timedelta64['ns', 1]), nat, equal_nan=True) assert np.array_equal(clnan.astype(np.timedelta64['ns', 1]), nat, equal_nan=True) test_datetime_nat_casting() @test def test_pydatetime_creation(): a = np.array(('1960-03-12', datetime.date(1960, 3, 12)), dtype='M8[D]') assert a[0] == a[1] a = np.array(('1999-12-31', datetime.date(1999, 12, 31)), dtype='M8[D]') assert a[0] == a[1] a = np.array(('2000-01-01', datetime.date(2000, 1, 1)), dtype='M8[D]') assert a[0] == a[1] test_pydatetime_creation() @test def test_timedelta_scalar_construction_units(): # String construction detecting units assert isinstance(np.datetime64('2010', 'Y'), np.datetime64['Y', 1]) assert isinstance(np.datetime64('2010-03', 'M'), np.datetime64['M', 1]) assert isinstance(np.datetime64('2010-03-12', 'D'), np.datetime64['D', 1]) assert isinstance(np.datetime64('2010-03-12T17', 'h'), np.datetime64['h', 1]) assert isinstance(np.datetime64('2010-03-12T17:15', 'm'), np.datetime64['m', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08', 's'), np.datetime64['s', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.1', 'ms'), np.datetime64['ms', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.12', 'ms'), np.datetime64['ms', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.123', 'ms'), np.datetime64['ms', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.1234', 'us'), np.datetime64['us', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.12345', 'us'), np.datetime64['us', 1]) assert isinstance(np.datetime64('2010-03-12T17:15:08.123456', 'us'), np.datetime64['us', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.1234567', 'ns'), np.datetime64['ns', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.12345678', 'ns'), np.datetime64['ns', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.123456789', 'ns'), np.datetime64['ns', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.1234567890', 'ps'), np.datetime64['ps', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.12345678901', 'ps'), np.datetime64['ps', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.123456789012', 'ps'), np.datetime64['ps', 1]) assert isinstance(np.datetime64('1970-01-01T00:00:02.1234567890123', 'fs'), np.datetime64['fs', 1]) assert isinstance( np.datetime64('1970-01-01T00:00:02.12345678901234', 'fs'), np.datetime64['fs', 1]) assert isinstance( np.datetime64('1970-01-01T00:00:02.123456789012345', 'fs'), np.datetime64['fs', 1]) assert isinstance( np.datetime64('1970-01-01T00:00:02.1234567890123456', 'as'), np.datetime64['as', 1]) assert isinstance( np.datetime64('1970-01-01T00:00:02.12345678901234567', 'as'), np.datetime64['as', 1]) assert isinstance( np.datetime64('1970-01-01T00:00:02.123456789012345678', 'as'), np.datetime64['as', 1]) # Python date object assert isinstance(np.datetime64(datetime.date(2010, 4, 16)), np.datetime64['D', 1]) # Python datetime object assert isinstance( np.datetime64(datetime.datetime(2010, 4, 16, 13, 45, 18)), np.datetime64['us', 1]) # 'today' special value assert isinstance(np.datetime64('today'), np.datetime64['us', 1]) # 'now' special value assert isinstance(np.datetime64('now'), np.datetime64['us', 1]) test_timedelta_scalar_construction_units() @test() def test_days_creation(): assert np.array_equal( np.array('1599', np.datetime64['D', 1]).astype(int), np.array((1600 - 1970) * 365 - (1972 - 1600) / 4 + 3 - 365)) assert np.array_equal( np.array('1600', np.datetime64['D', 1]).astype(int), np.array((1600 - 1970) * 365 - (1972 - 1600) / 4 + 3)) assert np.array_equal( np.array('1601', np.datetime64['D', 1]).astype(int), np.array((1600 - 1970) * 365 - (1972 - 1600) / 4 + 3 + 366)) assert np.array_equal( np.array('1900', np.datetime64['D', 1]).astype(int), np.array((1900 - 1970) * 365 - (1970 - 1900) // 4)) assert np.array_equal( np.array('1901', np.datetime64['D', 1]).astype(int), np.array((1900 - 1970) * 365 - (1970 - 1900) // 4 + 365)) assert np.array_equal( np.array('1967', np.datetime64['D', 1]).astype(int), np.array(-3 * 365 - 1)) assert np.array_equal( np.array('1968', np.datetime64['D', 1]).astype(int), np.array(-2 * 365 - 1)) assert np.array_equal( np.array('1969', np.datetime64['D', 1]).astype(int), np.array(-1 * 365)) assert np.array_equal( np.array('1970', np.datetime64['D', 1]).astype(int), np.array(0 * 365)) assert np.array_equal( np.array('1971', np.datetime64['D', 1]).astype(int), np.array(1 * 365)) assert np.array_equal( np.array('1972', np.datetime64['D', 1]).astype(int), np.array(2 * 365)) assert np.array_equal( np.array('1973', np.datetime64['D', 1]).astype(int), np.array(3 * 365 + 1)) assert np.array_equal( np.array('1974', np.datetime64['D', 1]).astype(int), np.array(4 * 365 + 1)) assert np.array_equal( np.array('2000', np.datetime64['D', 1]).astype(int), np.array((2000 - 1970) * 365 + (2000 - 1972) // 4)) assert np.array_equal( np.array('2001', np.datetime64['D', 1]).astype(int), np.array((2000 - 1970) * 365 + (2000 - 1972) // 4 + 366)) assert np.array_equal( np.array('2400', np.datetime64['D', 1]).astype(int), np.array((2400 - 1970) * 365 + (2400 - 1972) // 4 - 3)) assert np.array_equal( np.array('2401', np.datetime64['D', 1]).astype(int), np.array((2400 - 1970) * 365 + (2400 - 1972) // 4 - 3 + 366)) assert np.array_equal( np.array('1600-02-29', np.datetime64['D', 1]).astype(int), np.array((1600 - 1970) * 365 - (1972 - 1600) // 4 + 3 + 31 + 28)) assert np.array_equal( np.array('1600-03-01', np.datetime64['D', 1]).astype(int), np.array((1600 - 1970) * 365 - (1972 - 1600) // 4 + 3 + 31 + 29)) assert np.array_equal( np.array('2000-02-29', np.datetime64['D', 1]).astype(int), np.array((2000 - 1970) * 365 + (2000 - 1972) // 4 + 31 + 28)) assert np.array_equal( np.array('2000-03-01', np.datetime64['D', 1]).astype(int), np.array((2000 - 1970) * 365 + (2000 - 1972) // 4 + 31 + 29)) assert np.array_equal( np.array('2001-03-22', np.datetime64['D', 1]).astype(int), np.array((2000 - 1970) * 365 + (2000 - 1972) // 4 + 366 + 31 + 28 + 21)) test_days_creation() @test def test_datetime_string_conversion(): a = ['2011-03-16', '1920-01-01', '2013-05-19'] str_a = np.array(a, dtype='S') uni_a = np.array(a, dtype='U') dt_a = np.array(a, np.datetime64['D', 1]) # String to datetime assert np.array_equal(dt_a, str_a.astype(np.datetime64['D', 1])) assert isinstance(dt_a.dtype, str_a.astype(np.datetime64['D', 1]).dtype) dt_b = np.empty_like(dt_a) dt_b[...] = str_a assert np.array_equal(dt_a, dt_b) assert np.array_equal(dt_a, uni_a.astype(np.datetime64['D', 1])) assert isinstance(dt_a.dtype, uni_a.astype(np.datetime64['D', 1]).dtype) dt_b = np.empty_like(dt_a) dt_b[...] = uni_a assert np.array_equal(dt_a, dt_b) test_datetime_string_conversion() @test def test_month_truncation(): # Make sure that months are truncating correctly assert np.array_equal(np.array('1945-03-01', np.datetime64['M', 1]), np.array('1945-03-31', np.datetime64['M', 1])) assert np.array_equal( np.array('1969-11-01', np.datetime64['M', 1]), np.array('1969-11-30T23:59:59.99999', np.datetime64['M', 1]).astype(np.datetime64['M', 1])) assert np.array_equal( np.array('1969-12-01', np.datetime64['M', 1]), np.array('1969-12-31T23:59:59.99999', np.datetime64['M', 1]).astype(np.datetime64['M', 1])) assert np.array_equal( np.array('1970-01-01', np.datetime64['M', 1]), np.array('1970-01-31T23:59:59.99999', np.datetime64['M', 1]).astype(np.datetime64['M', 1])) assert np.array_equal( np.array('1980-02-01', np.datetime64['M', 1]), np.array('1980-02-29T23:59:59.99999', np.datetime64['M', 1]).astype(np.datetime64['M', 1])) test_month_truncation() @test def test_dtype_promotion(): a = np.array('2011-03-16', np.datetime64['Y', 12]) b = np.array('200', np.timedelta64['Y', 15]) assert np.array_equal(np.array('5006', np.datetime64['Y', 3]), a + b) a = np.array('2011-03-15', np.datetime64['Y', 2]) b = np.array('2001', np.timedelta64['Y', 2]) assert np.array_equal(np.array('6012', np.datetime64['Y', 2]), a + b) a = np.array('2011-03-15', np.datetime64['M', 62]) b = np.array('200', np.timedelta64['M', 24]) assert np.array_equal(np.array('2406-03', np.datetime64['M', 2]), a + b) a = np.array('2011-03-15', np.datetime64['W', 1]) b = np.array('200', np.timedelta64['D', 2]) assert np.array_equal(np.array('2012-04-13', np.datetime64['D', 1]), a + b) a = np.array('2011-03-15', np.datetime64['W', 1]) b = np.array('200', np.timedelta64['s', 13]) assert np.array_equal( np.array('2011-03-10T00:43:20', np.datetime64['s', 1]), a + b) test_dtype_promotion() @test def test_pyobject_roundtrip(): # All datetime types should be able to roundtrip through object a = np.array([ 0, 0, 0, 0, 0, 0, 0, 0, 0, -1020040340, -2942398, -1, 0, 1, 234523453, 1199164176 ], dtype=np.int64) # ['Y', 'M', 'D'] # With date units b = a.copy().view(dtype=np.datetime64['D', 1]) b[0] = '-0001-01-01' b[1] = '-0001-12-31' b[2] = '0000-01-01' b[3] = '0001-01-01' b[4] = '1969-12-31' b[5] = '1970-01-01' b[6] = '9999-12-31' b[7] = '10000-01-01' assert np.array_equal(b.astype(np.datetime64['D', 1]), b) b = a.copy().view(dtype=np.datetime64['W', 1]) b[0] = '-0001-01-01' b[1] = '-0001-12-31' b[2] = '0000-01-01' b[3] = '0001-01-01' b[4] = '1969-12-31' b[5] = '1970-01-01' b[6] = '9999-12-31' b[7] = '10000-01-01' assert np.array_equal(b.astype(np.datetime64['W', 1]), b) b = a.copy().view(dtype=np.datetime64['M', 1]) b[0] = '-0001-01-01' b[1] = '-0001-12-31' b[2] = '0000-01-01' b[3] = '0001-01-01' b[4] = '1969-12-31' b[5] = '1970-01-01' b[6] = '9999-12-31' b[7] = '10000-01-01' assert np.array_equal(b.astype(np.datetime64['M', 1]), b) b = a.copy().view(dtype=np.datetime64['Y', 1]) b[0] = '-0001-01-01' b[1] = '-0001-12-31' b[2] = '0000-01-01' b[3] = '0001-01-01' b[4] = '1969-12-31' b[5] = '1970-01-01' b[6] = '9999-12-31' b[7] = '10000-01-01' assert np.array_equal(b.astype(np.datetime64['Y', 1]), b) # With time units b = a.copy().view(dtype=np.datetime64['as', 1]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['as', 1]), b) b = a.copy().view(dtype=np.datetime64['fs', 16]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['fs', 16]), b) b = a.copy().view(dtype=np.datetime64['ps', 16]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['ps', 16]), b) b = a.copy().view(dtype=np.datetime64['us', 16]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['us', 16]), b) b = a.copy().view(dtype=np.datetime64['as', 300]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['as', 300]), b) b = a.copy().view(dtype=np.datetime64['us', 20]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['us', 20]), b) b = a.copy().view(dtype=np.datetime64['us', 56]) b[0] = '-0001-01-01T00' b[1] = '-0001-12-31T00' b[2] = '0000-01-01T00' b[3] = '0001-01-01T00' b[4] = '1969-12-31T23:59:59.999999' b[5] = '1970-01-01T00' b[6] = '9999-12-31T23:59:59.999999' b[7] = '10000-01-01T00' assert np.array_equal(b.astype(np.datetime64['us', 56]), b) test_pyobject_roundtrip() @test def test_different_unit_comparison(): assert np.array_equal(np.array('1945', dtype=(np.datetime64['Y', 1])), np.array('1945', dtype=(np.datetime64['Y', 1]))) assert np.array_equal(np.array('1970', dtype=(np.datetime64['Y', 1])), np.array('1970', dtype=(np.datetime64['Y', 1]))) assert np.array_equal(np.array('9999', dtype=(np.datetime64['Y', 1])), np.array('9999', dtype=(np.datetime64['Y', 1]))) assert np.array_equal( np.array('10000', dtype=(np.datetime64['Y', 1])), np.array('10000-01-01', dtype=(np.datetime64['Y', 1]))) assert np.datetime64('1945', 'Y') == np.datetime64('1945', 'Y') assert np.datetime64('1970', 'Y') == np.datetime64('1970', 'Y') assert np.datetime64('9999', 'Y') == np.datetime64('9999', 'Y') assert np.datetime64('10000', 'Y') == np.datetime64('10000-01-01', 'Y') assert np.array_equal(np.array('1945', dtype=(np.datetime64['Y', 1])), np.array('1945', dtype=(np.datetime64['M', 1]))) assert np.array_equal(np.array('1970', dtype=(np.datetime64['Y', 1])), np.array('1970', dtype=(np.datetime64['M', 1]))) assert np.array_equal(np.array('9999', dtype=(np.datetime64['Y', 1])), np.array('9999', dtype=(np.datetime64['M', 1]))) assert np.array_equal( np.array('10000', dtype=(np.datetime64['Y', 1])), np.array('10000-01-01', dtype=(np.datetime64['M', 1]))) assert np.datetime64('1945', 'Y') == np.datetime64('1945', 'M') assert np.datetime64('1970', 'Y') == np.datetime64('1970', 'M') assert np.datetime64('9999', 'Y') == np.datetime64('9999', 'M') assert np.datetime64('10000', 'Y') == np.datetime64('10000-01-01', 'M') assert np.array_equal(np.array('1945', dtype=(np.datetime64['Y', 1])), np.array('1945', dtype=(np.datetime64['D', 1]))) assert np.array_equal(np.array('1970', dtype=(np.datetime64['Y', 1])), np.array('1970', dtype=(np.datetime64['D', 1]))) assert np.array_equal(np.array('9999', dtype=(np.datetime64['Y', 1])), np.array('9999', dtype=(np.datetime64['D', 1]))) assert np.array_equal( np.array('10000', dtype=(np.datetime64['Y', 1])), np.array('10000-01-01', dtype=(np.datetime64['D', 1]))) assert np.datetime64('1945', 'Y') == np.datetime64('1945', 'D') assert np.datetime64('1970', 'Y') == np.datetime64('1970', 'D') assert np.datetime64('9999', 'Y') == np.datetime64('9999', 'D') assert np.datetime64('10000', 'Y') == np.datetime64('10000-01-01', 'D') assert np.array_equal(np.array('1945', dtype=(np.datetime64['M', 1])), np.array('1945', dtype=(np.datetime64['M', 1]))) assert np.array_equal(np.array('1970', dtype=(np.datetime64['M', 1])), np.array('1970', dtype=(np.datetime64['M', 1]))) assert np.array_equal(np.array('9999', dtype=(np.datetime64['M', 1])), np.array('9999', dtype=(np.datetime64['M', 1]))) assert np.array_equal( np.array('10000', dtype=(np.datetime64['M', 1])), np.array('10000-01-01', dtype=(np.datetime64['M', 1]))) assert np.datetime64('1945', 'M') == np.datetime64('1945', 'M') assert np.datetime64('1970', 'M') == np.datetime64('1970', 'M') assert np.datetime64('9999', 'M') == np.datetime64('9999', 'M') assert np.datetime64('10000', 'M') == np.datetime64('10000-01-01', 'M') assert np.array_equal(np.array('1945', dtype=(np.datetime64['D', 1])), np.array('1945', dtype=(np.datetime64['D', 1]))) assert np.array_equal(np.array('1970', dtype=(np.datetime64['D', 1])), np.array('1970', dtype=(np.datetime64['D', 1]))) assert np.array_equal(np.array('9999', dtype=(np.datetime64['D', 1])), np.array('9999', dtype=(np.datetime64['D', 1]))) assert np.array_equal( np.array('10000', dtype=(np.datetime64['D', 1])), np.array('10000-01-01', dtype=(np.datetime64['D', 1]))) assert np.datetime64('1945', 'D') == np.datetime64('1945', 'D') assert np.datetime64('1970', 'D') == np.datetime64('1970', 'D') assert np.datetime64('9999', 'D') == np.datetime64('9999', 'D') assert np.datetime64('10000', 'D') == np.datetime64('10000-01-01', 'D') assert np.array_equal( np.array('10000', dtype=(np.datetime64['M', 1])), np.array('10000-01-01', dtype=(np.datetime64['D', 1]))) assert np.datetime64('10000', 'M') == np.datetime64('10000-01-01', 'D') assert np.array_equal( np.array('10000', dtype=(np.datetime64['D', 1])), np.array('10000-01-01', dtype=(np.datetime64['Y', 1]))) assert np.datetime64('10000', 'D') == np.datetime64('10000-01-01', 'Y') assert np.array_equal( np.array('10000', dtype=(np.datetime64['D', 1])), np.array('10000-01-01', dtype=(np.datetime64['Y', 1]))) assert np.datetime64('10000', 'D') == np.datetime64('10000-01-01', 'Y') assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['D', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['D', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['D', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['D', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['h', 12]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['h', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['h', 12]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['h', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['h', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['h', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['h', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['h', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['m', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['m', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['m', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['m', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['s', 4]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['s', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['s', 4]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['s', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['s', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['s', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['s', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['s', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['ms', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['ms', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['ms', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['ms', 1])) assert np.array_equal( np.array('1932-02-17', dtype=np.datetime64['D', 1]).astype(np.datetime64['us', 1]), np.array('1932-02-17T00:00:00', dtype=np.datetime64['s', 1]).astype(np.datetime64['us', 1])) assert np.array_equal( np.array('10000-04-27', dtype=np.datetime64['D', 1]).astype(np.datetime64['us', 1]), np.array('10000-04-27T00:00:00', dtype='s').astype(np.datetime64['us', 1])) test_different_unit_comparison() @test def test_timedelta_modulus_error(): a = np.timedelta64(7, 's') b = np.timedelta64(3, 's') assert a % b == np.timedelta64(1, 's') # negative value cases a = np.timedelta64(3, 's') b = np.timedelta64(-2, 's') assert a % b == np.timedelta64(-1, 's') a = np.timedelta64(-3, 's') b = np.timedelta64(2, 's') assert a % b == np.timedelta64(1, 's') # larger value cases a = np.timedelta64(17, 's') b = np.timedelta64(22, 's') assert a % b == np.timedelta64(17, 's') a = np.timedelta64(22, 's') b = np.timedelta64(17, 's') assert a % b == np.timedelta64(5, 's') # different units a = np.timedelta64(1, 'm') b = np.timedelta64(57, 's') assert a % b == np.timedelta64(3, 's') a = np.timedelta64(1, 'us') b = np.timedelta64(727, 'ns') assert a % b == np.timedelta64(273, 'ns') # Y % M works a = np.timedelta64(2, 'Y') b = np.timedelta64(22, 'M') assert a % b == np.timedelta64(2, 'M') # NaT is propagated a = np.timedelta64('NaT', 'ns') b = np.timedelta64(50, 'ns') assert np.isnat(a % b) test_timedelta_modulus_error() @test def test_timedelta_modulus_div_by_zero(): actual = np.timedelta64(10, 's') % np.timedelta64(0, 's') assert np.isnat(actual) test_timedelta_modulus_div_by_zero() @test def test_timedelta_arange_no_dtype(): d = np.array([5], dtype=np.timedelta64['D', 1]) assert np.array_equal(np.arange(5, 6, np.timedelta64['D', 1]), d) assert np.array_equal(np.arange(5, np.timedelta64['D', 1]), np.arange(0, 5, np.timedelta64['D', 1])) test_timedelta_arange_no_dtype() @test def test_datetime_busday_offset(): assert np.busday_offset('2011-06', 0, roll='forward', weekmask='Mon') == np.datetime64( '2011-06-06', 'D') assert np.busday_offset('2011-07', -1, roll='forward', weekmask='Mon') == np.datetime64( '2011-06-27', 'D') assert np.busday_offset('2010-08', 0, roll='backward') == np.datetime64( '2010-07-30', 'D') assert np.busday_offset('2010-08', 0, roll='preceding') == np.datetime64( '2010-07-30', 'D') assert np.busday_offset('2010-08', 0, roll='modifiedpreceding') == np.datetime64( '2010-08-02', 'D') assert np.busday_offset('2010-08', 0, roll='modifiedfollowing') == np.datetime64( '2010-08-02', 'D') assert np.busday_offset('2010-08', 0, roll='forward') == np.datetime64( '2010-08-02', 'D') assert np.busday_offset('2010-08', 0, roll='following') == np.datetime64( '2010-08-02', 'D') assert np.busday_offset('2010-10-30', 0, roll='following') == np.datetime64( '2010-11-01', 'D') assert np.busday_offset('2010-10-30', 0, roll='modifiedfollowing') == np.datetime64( '2010-10-29', 'D') assert np.busday_offset('2010-10-30', 0, roll='modifiedpreceding') == np.datetime64( '2010-10-29', 'D') assert np.busday_offset('2010-10-16', 0, roll='modifiedpreceding') == np.datetime64( '2010-10-15', 'D') assert np.busday_offset('2010-10-16', 0, roll='modifiedfollowing') == np.datetime64( '2010-10-18', 'D') # Bigger offset values assert np.busday_offset('2006-02-01', 25) == np.datetime64('2006-03-08', 'D') assert np.busday_offset('2006-03-08', -25) == np.datetime64('2006-02-01', 'D') # NaT values when roll is not raise assert np.isnat(np.busday_offset(np.datetime64('NaT', 'D'), 1, roll='nat')) assert np.isnat( np.busday_offset(np.datetime64('NaT', 'D'), 1, roll='following')) assert np.isnat( np.busday_offset(np.datetime64('NaT', 'D'), 1, roll='preceding')) test_datetime_busday_offset() @test def test_datetime_busdaycalendar(): # Check that it removes NaT, duplicates, and weekends # and sorts the result. bdd = np.busdaycalendar(holidays=[ 'NaT', '2011-01-17', '2011-03-06', 'NaT', '2011-12-26', '2011-05-30', '2011-01-17' ]) assert np.array_equal( bdd.holidays, np.array(['2011-01-17', '2011-05-30', '2011-12-26'], np.datetime64('NaT', 'D'))) # Default M-F weekmask assert np.array_equal(bdd.weekmask, np.array([1, 1, 1, 1, 1, 0, 0], dtype=bool)) # Check length 7 0/1 string bdd = np.busdaycalendar(weekmask="0011001") assert np.array_equal(bdd.weekmask, np.array([0, 0, 1, 1, 0, 0, 1], dtype=bool)) # Check length 7 string weekmask. bdd = np.busdaycalendar(weekmask="Mon Tue") assert np.array_equal(bdd.weekmask, np.array([1, 1, 0, 0, 0, 0, 0], dtype=bool)) # All-zeros weekmask should raise try: np.busdaycalendar(weekmask=[0, 0, 0, 0, 0, 0, 0]) assert False except ValueError: pass # weekday names must be correct case try: np.busdaycalendar(weekmask="satsun") assert False except ValueError: pass # All-zeros weekmask should raise try: np.busdaycalendar(weekmask="") assert False except ValueError: pass # Invalid weekday name codes should raise try: np.busdaycalendar(weekmask="Mon Tue We") assert False except ValueError: pass try: np.busdaycalendar(weekmask="Max") assert False except ValueError: pass try: np.busdaycalendar(weekmask="Monday Tue") assert False except ValueError: pass test_datetime_busdaycalendar() @test def test_datetime_busday_holidays_offset(): # With exactly one holiday assert np.busday_offset('2011-11-10', 1, holidays=['2011-11-11' ]) == np.datetime64('2011-11-14', 'D') assert np.busday_offset('2011-11-04', 5, holidays=['2011-11-11' ]) == np.datetime64('2011-11-14', 'D') assert np.busday_offset('2011-11-10', 5, holidays=['2011-11-11' ]) == np.datetime64('2011-11-18', 'D') # With the holiday appearing twice assert np.busday_offset('2011-11-10', 1, holidays=['2011-11-11', '2011-11-11' ]) == np.datetime64('2011-11-14', 'D') # With a NaT holiday assert np.busday_offset('2011-11-10', 1, holidays=['2011-11-11', 'NaT' ]) == np.datetime64('2011-11-14', 'D') # With another holiday after assert np.busday_offset('2011-11-10', 1, holidays=['2011-11-11', '2011-11-24' ]) == np.datetime64('2011-11-14', 'D') assert np.busday_offset('2011-11-14', -1, holidays=['2011-11-11', '2011-11-24' ]) == np.datetime64('2011-11-10', 'D') # With another holiday before assert np.busday_offset('2011-11-10', 1, holidays=['2011-10-10', '2011-11-11' ]) == np.datetime64('2011-11-14', 'D') # With another holiday before and after assert np.busday_offset('2011-11-10', 1, holidays=[ '2011-10-10', '2011-11-11', '2011-11-24' ]) == np.datetime64('2011-11-14', 'D') assert np.busday_offset('2011-11-14', -1, holidays=[ '2011-10-10', '2011-11-11', '2011-11-24' ]) == np.datetime64('2011-11-10', 'D') # A bigger forward jump across more than one week/holiday holidays = [ '2011-10-10', '2011-11-11', '2011-11-24', '2011-12-25', '2011-05-30', '2011-02-21', '2011-12-26', '2012-01-02' ] bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays) assert np.busday_offset('2011-10-03', 4, holidays=holidays) == np.busday_offset( '2011-10-03', 4) assert np.busday_offset('2011-10-03', 5, holidays=holidays) == np.busday_offset( '2011-10-03', 5 + 1) assert np.busday_offset('2011-10-03', 27, holidays=holidays) == np.busday_offset( '2011-10-03', 27 + 1) assert np.busday_offset('2011-10-03', 28, holidays=holidays) == np.busday_offset( '2011-10-03', 28 + 2) assert np.busday_offset('2011-10-03', 35, holidays=holidays) == np.busday_offset( '2011-10-03', 35 + 2) assert np.busday_offset('2011-10-03', 36, holidays=holidays) == np.busday_offset( '2011-10-03', 36 + 3) assert np.busday_offset('2011-10-03', 56, holidays=holidays) == np.busday_offset( '2011-10-03', 56 + 3) assert np.busday_offset('2011-10-03', 57, holidays=holidays) == np.busday_offset( '2011-10-03', 57 + 4) assert np.busday_offset('2011-10-03', 60, holidays=holidays) == np.busday_offset( '2011-10-03', 60 + 4) assert np.busday_offset('2011-10-03', 61, holidays=holidays) == np.busday_offset( '2011-10-03', 61 + 5) # Roll with the holidays assert np.busday_offset('2011-12-25', 0, roll='forward', holidays=holidays) == np.datetime64('2011-12-27') assert np.busday_offset('2011-12-26', 0, roll='forward', holidays=holidays) == np.datetime64('2011-12-27') assert np.busday_offset('2011-12-26', 0, roll='backward', holidays=holidays) == np.datetime64('2011-12-23') assert np.busday_offset('2012-02-27', 0, roll='modifiedfollowing', holidays=[ '2012-02-27', '2012-02-26', '2012-02-28', '2012-03-01', '2012-02-29' ]) == np.datetime64('2012-02-24') assert np.busday_offset('2012-03-06', 0, roll='modifiedpreceding', holidays=[ '2012-03-02', '2012-03-03', '2012-03-01', '2012-03-05', '2012-03-07', '2012-03-06' ]) == np.datetime64('2012-03-08') test_datetime_busday_holidays_offset() @test def test_datetime_busday_holidays_count(): holidays = [ '2011-01-01', '2011-10-10', '2011-11-11', '2011-11-24', '2011-12-25', '2011-05-30', '2011-02-21', '2011-01-17', '2011-12-26', '2012-01-02', '2011-02-21', '2011-05-30', '2011-07-01', '2011-07-04', '2011-09-05', '2011-10-10' ] bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays) # Validate against busday_offset broadcast against # a range of offsets dates = np.busday_offset('2011-01-01', np.arange(366), roll='forward', busdaycal=bdd) assert np.array_equal(np.busday_count('2011-01-01', dates, busdaycal=bdd), np.arange(366)) # Returns negative value when reversed # -1 since the '2011-01-01' is not a busday assert np.array_equal(np.busday_count(dates, '2011-01-01', busdaycal=bdd), -np.arange(366) - 1) # 2011-12-31 is a saturday dates = np.busday_offset('2011-12-31', -np.arange(366), roll='forward', busdaycal=bdd) # only the first generated date is in the future of 2011-12-31 expected = np.arange(366) expected[0] = -1 # Returns negative value when reversed expected = -np.arange(366) + 1 expected[0] = 0 # Number of Mondays in March 2011 assert np.busday_count('2011-03', '2011-04', weekmask='Mon') == 4 # Returns negative value when reversed assert np.busday_count('2011-04', '2011-03', weekmask='Mon') == -4 sunday = np.datetime64('2023-03-05') monday = sunday + 1 friday = sunday + 5 saturday = sunday + 6 assert np.busday_count(sunday, monday) == 0 assert np.busday_count(saturday, friday) == 0 test_datetime_busday_holidays_count() @test def test_datetime_add(): for dta, dtb, dtc, dtnat, tda, tdb, tdc in \ ( (np.array(['2012-12-21'], dtype=np.datetime64['D', 1]), np.array(['2012-12-24'], dtype=np.datetime64['D', 1]), np.array(['2012-12-21T11'], dtype=np.datetime64['h', 1]), np.array(['NaT'], dtype=np.datetime64['D', 1]), np.array([3], dtype=np.timedelta64['D', 1]), np.array([11], dtype=np.timedelta64['h', 1]), np.array([3*24 + 11], dtype=np.timedelta64['h', 1])), (np.datetime64('2012-12-21', 'D'), np.datetime64('2012-12-24', 'D'), np.datetime64('2012-12-21T11', 'h'), np.datetime64('NaT', 'D'), np.timedelta64(3, 'D'), np.timedelta64(11, 'h'), np.timedelta64(3*24 + 11, 'h'))): assert array_equal(tda + tdb, tdc) if isinstance((tda + tdb), ndarray): assert isinstance((tda + tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((tda + tdb), np.timedelta64['h', 1]) assert array_equal(tdb + True, tdb + 1) if isinstance((tdb + True), ndarray): assert isinstance((tdb + True).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdb + True), np.timedelta64['h', 1]) assert array_equal(tdb + 3 * 24, tdc) if isinstance((tdb + 3 * 24), ndarray): assert isinstance((tdb + 3 * 24).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdb + 3 * 24), np.timedelta64['h', 1]) assert array_equal(False + tdb, tdb) if isinstance((False + tdb), ndarray): assert isinstance((False + tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((False + tdb), np.timedelta64['h', 1]) assert array_equal(3 * 24 + tdb, tdc) if isinstance((3 * 24 + tdb), ndarray): assert isinstance((3 * 24 + tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((3 * 24 + tdb), np.timedelta64['h', 1]) assert array_equal(dta + True, dta + 1) assert array_equal(isnat(dtnat + True), isnat(dtnat)) if isinstance((dta + True), ndarray): assert isinstance((dta + True).dtype, np.datetime64['D', 1]) else: assert isinstance((dta + True), np.datetime64['D', 1]) assert array_equal(dta + 3, dtb) assert array_equal(isnat(dtnat + 3), isnat(dtnat)) if isinstance((dta + 3), ndarray): assert isinstance((dta + 3).dtype, np.datetime64['D', 1]) else: assert isinstance((dta + 3), np.datetime64['D', 1]) assert array_equal(False + dta, dta) assert array_equal(isnat(False + dtnat), isnat(dtnat)) if isinstance((False + dta), ndarray): assert isinstance((False + dta).dtype, np.datetime64['D', 1]) else: assert isinstance((False + dta), np.datetime64['D', 1]) assert array_equal(3 + dta, dtb) assert array_equal(isnat(3 + dtnat), isnat(dtnat)) if isinstance((3 + dta), ndarray): assert isinstance((3 + dta).dtype, np.datetime64['D', 1]) else: assert isinstance((3 + dta), np.datetime64['D', 1]) assert array_equal(dta + tda, dtb) assert array_equal(isnat(dtnat + tda), isnat(dtnat)) if isinstance((dta + tda), ndarray): assert isinstance((dta + tda).dtype, np.datetime64['D', 1]) else: assert isinstance((dta + tda), np.datetime64['D', 1]) assert array_equal(tda + dta, dtb) assert array_equal(isnat(tda + dtnat), isnat(dtnat)) if isinstance((tda + dta), ndarray): assert isinstance((tda + dta).dtype, np.datetime64['D', 1]) else: assert isinstance((tda + dta), np.datetime64['D', 1]) assert array_equal(np.add(dta, tdb), dtc) if isinstance(np.add(dta, tdb), ndarray): assert isinstance(np.add(dta, tdb).dtype, np.datetime64['h', 1]) else: assert isinstance(np.add(dta, tdb), np.datetime64['h', 1]) assert array_equal(np.add(tdb, dta), dtc) if isinstance(np.add(dta, tdb), ndarray): assert isinstance(np.add(tdb, dta).dtype, np.datetime64['h', 1]) else: assert isinstance(np.add(tdb, dta), np.datetime64['h', 1]) test_datetime_add() @test def test_datetime_subtract(): for dta, dtb, dtc, dtd, dte, dtnat, tda, tdb, tdc in \ ( (np.array(['2012-12-21'], dtype=np.datetime64['D', 1]), np.array(['2012-12-24'], dtype=np.datetime64['D', 1]), np.array(['1940-12-24'], dtype=np.datetime64['D', 1]), np.array(['1940-12-24T00'], dtype=np.datetime64['h',1]), np.array(['1940-12-23T13'], dtype=np.datetime64['h', 1]), np.array(['NaT'], dtype=np.datetime64['D', 1]), np.array([3], dtype=np.timedelta64['D', 1]), np.array([11], dtype=np.timedelta64['h', 1]), np.array([3*24 - 11], dtype=np.timedelta64['h', 1])), (np.datetime64('2012-12-21', 'D'), np.datetime64('2012-12-24', 'D'), np.datetime64('1940-12-24', 'D'), np.datetime64('1940-12-24T00', 'h'), np.datetime64('1940-12-23T13', 'h'), np.datetime64('NaT', 'D'), np.timedelta64(3, 'D'), np.timedelta64(11, 'h'), np.timedelta64(3*24 - 11, 'h'))): assert array_equal(tda - tdb, tdc) if isinstance((tda - tdb), ndarray): assert isinstance((tda - tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((tda - tdb), np.timedelta64['h', 1]) assert array_equal(tdb - tda, -tdc) if isinstance((tdb - tda), ndarray): assert isinstance((tdb - tda).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdb - tda), np.timedelta64['h', 1]) assert array_equal(tdc - True, tdc - 1) if isinstance((tdc - True), ndarray): assert isinstance((tdc - True).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdc - True), np.timedelta64['h', 1]) assert array_equal(tdc - 3 * 24, -tdb) if isinstance((tdb - 3 * 24), ndarray): assert isinstance((tdb - 3 * 24).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdb - 3 * 24), np.timedelta64['h', 1]) assert array_equal(False - tdb, -tdb) if isinstance((False - tdb), ndarray): assert isinstance((False - tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((False - tdb), np.timedelta64['h', 1]) assert array_equal(3 * 24 - tdb, tdc) if isinstance((3 * 24 - tdb), ndarray): assert isinstance((3 * 24 - tdb).dtype, np.timedelta64['h', 1]) else: assert isinstance((3 * 24 - tdb), np.timedelta64['h', 1]) assert array_equal(dtb - True, dtb - 1) assert array_equal(isnat(dtnat - True), isnat(dtnat)) if isinstance((tdb - True), ndarray): assert isinstance((tdb - True).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdb - True), np.timedelta64['h', 1]) assert array_equal(dtb - 3, dta) assert array_equal(isnat(dtnat - 3), isnat(dtnat)) if isinstance((dtb - 3), ndarray): assert isinstance((dtb - 3).dtype, np.datetime64['D', 1]) else: assert isinstance((dtb - 3), np.datetime64['D', 1]) assert array_equal(dtb - tda, dta) assert array_equal(isnat(dtnat - tda), isnat(dtnat)) if isinstance((dtb - tda), ndarray): assert isinstance((dtb - tda).dtype, np.datetime64['D', 1]) else: assert isinstance((dtb - tda), np.datetime64['D', 1]) assert array_equal(np.subtract(dtc, tdb), dte) if isinstance(np.subtract(dtc, tdb), ndarray): assert isinstance( np.subtract(dtc, tdb).dtype, np.datetime64['h', 1]) else: assert isinstance(np.subtract(dtc, tdb), np.datetime64['h', 1]) assert (np.subtract(dtc, dtd) == np.array(0, dtype=np.timedelta64['h', 1])) if isinstance(np.subtract(dtc, dtd), ndarray): assert isinstance( np.subtract(dtc, dtd).dtype, np.timedelta64['h', 1]) else: assert isinstance(np.subtract(dtc, dtd), np.timedelta64['h', 1]) assert (np.subtract(dtd, dtc) == np.array(0, dtype=np.timedelta64['h', 1])) if isinstance(np.subtract(dtd, dtc), ndarray): assert isinstance( np.subtract(dtd, dtc).dtype, np.timedelta64['h', 1]) else: assert isinstance(np.subtract(dtd, dtc), np.timedelta64['h', 1]) test_datetime_subtract() @test def test_datetime_multiply(): for dta, tda, tdb, tdc in \ ( (np.array(['2012-12-21'], dtype=np.datetime64['D',1]), np.array([6], dtype=np.timedelta64['h',1]), np.array([9], dtype=np.timedelta64['h',1]), np.array([12], dtype=np.timedelta64['h',1])), (np.datetime64('2012-12-21', 'D'), np.timedelta64(6, 'h'), np.timedelta64(9, 'h'), np.timedelta64(12, 'h'))): assert array_equal(tda * 2, tdc) if isinstance((tda * 2), ndarray): assert isinstance((tda * 2).dtype, np.timedelta64['h', 1]) else: assert isinstance((tda * 2), np.timedelta64['h', 1]) assert array_equal(2 * tda, tdc) if isinstance((2 * tda), ndarray): assert isinstance((2 * tda).dtype, np.timedelta64['h', 1]) else: assert isinstance((2 * tda), np.timedelta64['h', 1]) assert array_equal(tda * 1.5, tdb) if isinstance((tda * 1.5), ndarray): assert isinstance((tda * 1.5).dtype, np.timedelta64['h', 1]) else: assert isinstance((tda * 1.5), np.timedelta64['h', 1]) assert array_equal(1.5 * tda, tdb) if isinstance((1.5 * tda), ndarray): assert isinstance((1.5 * tda).dtype, np.timedelta64['h', 1]) else: assert isinstance((1.5 * tda), np.timedelta64['h', 1]) test_datetime_multiply() @test def test_datetime_divide(): for dta, tda, tdb, tdc, tdd in \ ( (np.array(['2012-12-21'], dtype=np.datetime64['D',1]), np.array([6], dtype=np.timedelta64['h',1]), np.array([9], dtype=np.timedelta64['h',1]), np.array([12], dtype=np.timedelta64['h',1]), np.array([6], dtype=np.timedelta64['h',1])), (np.datetime64('2012-12-21', 'D'), np.timedelta64(6, 'h'), np.timedelta64(9, 'h'), np.timedelta64(12, 'h'), np.timedelta64(6, 'm'))): assert array_equal(tdc / 2, tda) if isinstance((tdc / 2), ndarray): assert isinstance((tdc / 2).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdc / 2), np.timedelta64['h', 1]) assert array_equal(tda / 0.5, tdc) if isinstance((tdc / 0.5), ndarray): assert isinstance((tdc / 0.5).dtype, np.timedelta64['h', 1]) else: assert isinstance((tdc / 0.5), np.timedelta64['h', 1]) test_datetime_divide() @test def test_datetime_compare(): a = np.datetime64('2000-03-12T18:00:00.000000', 'us') b = np.array([ '2000-03-12T18:00:00.000000', '2000-03-12T17:59:59.999999', '2000-03-12T18:00:00.000001', '1970-01-11T12:00:00.909090', '2016-01-11T12:00:00.909090' ], dtype=np.datetime64['us', 1]) assert array_equal(np.equal(a, b), [1, 0, 0, 0, 0]) assert array_equal(np.not_equal(a, b), [0, 1, 1, 1, 1]) assert (np.less(a, b) == np.array([0, 0, 1, 0, 1])).all() assert array_equal(np.less_equal(a, b), [1, 0, 1, 0, 1]) assert array_equal(np.greater(a, b), [0, 1, 0, 1, 0]) assert array_equal(np.greater_equal(a, b), [1, 1, 0, 1, 0]) test_datetime_compare() @test def test_datetime_compare_nat(): dt_nat = np.datetime64('NaT', 'D') dt_other = np.datetime64('2000-01-01', 'D') td_nat = np.timedelta64('NaT', 'h') td_other = np.timedelta64(1, 'h') for op in (np.equal, np.less, np.less_equal, np.greater, np.greater_equal): assert (not op(dt_nat, dt_nat)) assert (not op(dt_nat, dt_other)) assert (not op(dt_other, dt_nat)) assert (not op(td_nat, td_nat)) assert (not op(td_nat, td_other)) assert (not op(td_other, td_nat)) assert (np.not_equal(dt_nat, dt_nat)) assert (np.not_equal(dt_nat, dt_other)) assert (np.not_equal(dt_other, dt_nat)) assert (np.not_equal(td_nat, td_nat)) assert (np.not_equal(td_nat, td_other)) assert (np.not_equal(td_other, td_nat)) test_datetime_compare_nat() @test def test_datetime_minmax(): a = np.array('1999-03-12T13', dtype=np.datetime64['m', 2]) b = np.array('1999-03-12T12', dtype=np.datetime64['s', 1]) assert array_equal(np.minimum(a, b), b) assert (isinstance(np.minimum(a, b), np.datetime64['s', 1])) assert array_equal(np.fmin(a, b), b) assert isinstance(np.fmin(a, b), np.datetime64['s', 1]) assert array_equal(np.maximum(a, b), a) assert isinstance(np.maximum(a, b), np.datetime64['s', 1]) assert array_equal(np.fmax(a, b), a) assert array_equal(np.minimum(a.view(int), b.view(int)), a.view(int)) a = np.array('1999-03-12T13', dtype=np.datetime64['m', 2]) dtnat = np.array('NaT', dtype=np.datetime64['h', 1]) assert array_equal(isnan(np.minimum(a, dtnat)), isnan(dtnat)) assert array_equal(isnan(np.minimum(dtnat, a)), isnan(dtnat)) assert array_equal(isnan(np.maximum(a, dtnat)), isnan(dtnat)) assert array_equal(isnan(np.maximum(dtnat, a)), isnan(dtnat)) assert array_equal(np.fmin(dtnat, a), a) assert array_equal(np.fmin(a, dtnat), a) assert array_equal(np.fmax(dtnat, a), a) assert array_equal(np.fmax(a, dtnat), a) a = np.array(3, dtype=np.timedelta64['h', 1]) b = np.array(3 * 3600 - 3, dtype=np.timedelta64['s', 1]) assert array_equal(np.minimum(a, b), b) assert isinstance(np.minimum(a, b), np.timedelta64['s', 1]) assert array_equal(np.fmin(a, b), b) assert isinstance(np.fmin(a, b), np.timedelta64['s', 1]) assert array_equal(np.maximum(a, b), a) assert isinstance(np.maximum(a, b), np.timedelta64['s', 1]) assert array_equal(np.fmax(a, b), a) assert isinstance(np.fmax(a, b), np.timedelta64['s', 1]) assert array_equal(np.minimum(a.view(int), b.view(int)), a.view(int)) test_datetime_minmax() @test def test_string_parser_variants(): assert array_equal( np.array(['1980-02-29T01:02:03'], dtype=np.datetime64['s', 1]), np.array(['1980-02-29 01:02:03'], dtype=np.datetime64['s', 1])) assert array_equal( np.array(['+1980-02-29T01:02:03'], dtype=np.datetime64['s', 1]), np.array(['+1980-02-29 01:02:03'], dtype=np.datetime64['s', 1])) assert array_equal( np.array(['-1980-02-29T01:02:03'], dtype=np.datetime64['s', 1]), np.array(['-1980-02-29 01:02:03'], dtype=np.datetime64['s', 1])) assert array_equal( np.array(['+1980-02-29T01:02:03'], dtype=np.datetime64['s', 1]), np.array(['+1980-02-29 01:02:03Z'], dtype=np.datetime64['s', 1])) assert array_equal( np.array(['-1980-02-29T01:02:03'], np.datetime64['s', 1]), np.array(['-1980-02-29 01:02:03Z'], np.datetime64['s', 1])) assert array_equal( np.array(['1980-02-29T02:02:03'], np.datetime64['s', 1]), np.array(['1980-02-29 00:32:03-0130'], np.datetime64['s', 1])) assert array_equal( np.array(['1980-02-28T22:32:03'], np.datetime64['s', 1]), np.array(['1980-02-29 00:02:03+01:30'], np.datetime64['s', 1])) assert array_equal( np.array(['1980-02-29T02:32:03.506'], np.datetime64['s', 1]), np.array(['1980-02-29 00:32:03.506-02'], np.datetime64['s', 1])) assert array_equal(np.datetime64('1977-03-02T12:30-0230'), np.datetime64('1977-03-02T15:00')) test_string_parser_variants() @test def test_string_parser_error_check(): msg = "no explicit representation of timezones available for " \ "np.datetime64" try: np.array('badvalue', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980X', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-00', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-13', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-1', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-1-02', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-Mor', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-01-', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-01-0', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-01-00', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-01-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1979-02-29', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-30', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-03-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-04-31', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-05-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-06-31', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-07-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-08-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-09-31', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-10-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-11-31', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-12-32', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03%', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 q', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 25', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03T25', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 24:01', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03T24:01', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 -1', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:-1', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:60', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:60:', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:10:-1', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:60', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:00+0661', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:00+2500', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:00-0070', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:00-3000', np.datetime64['us', 1]) assert False except ValueError: pass try: np.array('1980-02-03 01:01:00-25:00', np.datetime64['us', 1]) assert False except ValueError: pass test_string_parser_error_check() @test def test_datetime_as_string(): # Check all the units with default string conversion date = '1959-10-13' datetime = '1959-10-13T12:34:56.789012345678901234' assert array_equal(np.datetime_as_string(np.datetime64(date, 'Y')), '1959') assert array_equal(np.datetime_as_string(np.datetime64(date, 'M')), '1959-10') assert array_equal(np.datetime_as_string(np.datetime64(date, 'D')), '1959-10-13') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'h')), '1959-10-13T12') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'm')), '1959-10-13T12:34') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 's')), '1959-10-13T12:34:56') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'ms')), '1959-10-13T12:34:56.789') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'us')), '1959-10-13T12:34:56.789012') datetime = '1969-12-31T23:34:56.789012345678901234' assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'ns')), '1969-12-31T23:34:56.789012345') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'ps')), '1969-12-31T23:34:56.789012345678') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'fs')), '1969-12-31T23:34:56.789012345678901') datetime = '1969-12-31T23:59:57.789012345678901234' assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'as')), datetime) datetime = '1970-01-01T00:34:56.789012345678901234' assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'ns')), '1970-01-01T00:34:56.789012345') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'ps')), '1970-01-01T00:34:56.789012345678') assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'fs')), '1970-01-01T00:34:56.789012345678901') datetime = '1970-01-01T00:00:05.789012345678901234' assert array_equal(np.datetime_as_string(np.datetime64(datetime, 'as')), datetime) a = np.datetime64('2032-07-18T12:23:34.123456', 'us') assert array_equal(np.datetime_as_string(a, unit='h'), '2032-07-18T12') assert array_equal(np.datetime_as_string(a, unit='m'), '2032-07-18T12:23') assert array_equal(np.datetime_as_string(a, unit='s'), '2032-07-18T12:23:34') assert array_equal(np.datetime_as_string(a, unit='ms'), '2032-07-18T12:23:34.123') assert array_equal(np.datetime_as_string(a, unit='us'), '2032-07-18T12:23:34.123456') assert array_equal(np.datetime_as_string(a, unit='ns'), '2032-07-18T12:23:34.123456000') assert array_equal(np.datetime_as_string(a, unit='ps'), '2032-07-18T12:23:34.123456000000') assert array_equal(np.datetime_as_string(a, unit='fs'), '2032-07-18T12:23:34.123456000000000') assert array_equal(np.datetime_as_string(a, unit='as'), '2032-07-18T12:23:34.123456000000000000') # unit='auto' parameter assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T12:23:34.123456', 'us'), unit='auto'), '2032-07-18T12:23:34.123456') assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T12:23:34.12', 'us'), unit='auto'), '2032-07-18T12:23:34.120') assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T12:23:34', 'us'), unit='auto'), '2032-07-18T12:23:34') assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T12:23:00', 'us'), unit='auto'), '2032-07-18T12:23') # 'auto' doesn't split up hour and minute assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T12:00:00', 'us'), unit='auto'), '2032-07-18T12:00') assert array_equal( np.datetime_as_string(np.datetime64('2032-07-18T00:00:00', 'us'), unit='auto'), '2032-07-18') # 'auto' doesn't split up the date assert array_equal( np.datetime_as_string(np.datetime64('2032-07-01T00:00:00', 'us'), unit='auto'), '2032-07-01') assert array_equal( np.datetime_as_string(np.datetime64('2032-01-01T00:00:00', 'us'), unit='auto'), '2032-01-01') test_datetime_as_string() def test_datetime_as_string_timezone(): # timezone='local' vs 'UTC' a = np.datetime64('2010-03-15T06:30', 'm') assert array_equal(np.datetime_as_string(a), '2010-03-15T06:30') assert array_equal(np.datetime_as_string(a, timezone='naive'), '2010-03-15T06:30') assert array_equal(np.datetime_as_string(a, timezone='UTC'), '2010-03-15T06:30Z') assert (np.datetime_as_string(a, timezone='local') != '2010-03-15T06:30') b = np.datetime64('2010-02-15T06:30', 'm') test_datetime_as_string_timezone() def test_datetime_arange(): # With two datetimes provided as strings a = np.arange('2010-01-05', '2010-01-10', dtype=np.datetime64['D', 1]) assert isinstance(a.dtype, np.datetime64['D', 1]) assert array_equal( a, np.array([ '2010-01-05', '2010-01-06', '2010-01-07', '2010-01-08', '2010-01-09' ], dtype=np.datetime64['D', 1])) a = np.arange('1950-02-10', '1950-02-06', -1, dtype=np.datetime64['D', 1]) assert isinstance(a.dtype, np.datetime64['D', 1]) assert array_equal( a, np.array(['1950-02-10', '1950-02-09', '1950-02-08', '1950-02-07'], dtype=np.datetime64['D', 1])) # # # Unit should be detected as months here a = np.arange('1969-05', '1970-05', 2, dtype=np.datetime64['M', 1]) assert isinstance(a.dtype, np.datetime64['M', 1]) assert array_equal( a, np.array('1969-05', np.datetime64['M', 1]) + np.arange(12, step=2)) a = np.arange('1969', 18, 3, dtype=np.datetime64['Y', 1]) assert isinstance(a.dtype, np.datetime64['Y', 1]) assert array_equal( a, np.array('1969', dtype=np.datetime64['Y', 1]) + np.arange(18, step=3)) a = np.arange('1969-12-19', 22, np.timedelta64(2, 'D'), dtype=np.datetime64['D', 1]) assert array_equal(a.dtype, np.datetime64['D', 1]) assert array_equal( a, np.array('1969-12-19', dtype=np.datetime64['D', 1]) + np.arange(22, step=2)) try: np.arange(np.datetime64('today'), np.datetime64('today') + 3, 0) assert False except ValueError: pass test_datetime_arange() @test def test_timedelta_arange(): a = np.arange(3, 10, dtype=np.timedelta64['generic', 1]) assert array_equal(a.dtype, np.timedelta64['generic', 1]) assert array_equal( a, np.array(0, dtype=np.timedelta64['generic', 1]) + np.arange(3, 10)) a = np.arange(np.timedelta64(3, 's'), 10, 2, dtype=np.timedelta64['generic', 1]) assert array_equal(a.dtype, np.timedelta64['s', 1]) assert array_equal( a, np.array(0, dtype=np.timedelta64['s', 1]) + np.arange(3, 10, 2)) try: np.arange(np.timedelta64(0, 'generic'), np.timedelta64(5, 'generic'), 0) assert False except ValueError: pass test_timedelta_arange() @test def test_datetime_is_busday(): holidays = [ '2011-01-01', '2011-10-10', '2011-11-11', '2011-11-24', '2011-12-25', '2011-05-30', '2011-02-21', '2011-01-17', '2011-12-26', '2012-01-02', '2011-02-21', '2011-05-30', '2011-07-01', '2011-07-04', '2011-09-05', '2011-10-10', 'NaT' ] bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays) # Weekend/weekday tests assert array_equal(np.is_busday('2011-01-01'), False) assert array_equal(np.is_busday('2011-01-02'), False) assert array_equal(np.is_busday('2011-01-03'), True) test_datetime_is_busday() @test def test_isnat(): assert (isnat(np.datetime64('NaT', 'ms'))) assert (isnat(np.datetime64('NaT', 'ns'))) assert (not isnat(np.datetime64('2038-01-19T03:14:07'))) assert (isnat(np.timedelta64('NaT', "ms"))) assert (not isnat(np.timedelta64(34, "ms"))) test_isnat() @test def test_isfinite_scalar(): assert (not isfinite(np.datetime64('NaT', 'ms'))) assert (not isfinite(np.datetime64('NaT', 'ns'))) assert (isfinite(np.datetime64('2038-01-19T03:14:07'))) assert (not isfinite(np.timedelta64('NaT', "ms"))) assert (isfinite(np.timedelta64(34, "ms"))) test_isfinite_scalar() @test def test_datetime64(): assert np.datetime64(np.datetime64('2009', 'Y'), 'Y') == np.datetime64("2009") assert np.datetime64(np.datetime64('2009', 'M'), 'M') == np.datetime64("2009-01") assert np.datetime64(np.datetime64('2009', 'D'), 'D') == np.datetime64("2009-01-01") assert np.timedelta64(np.timedelta64(1, 'Y'), 'Y') == np.timedelta64("1") assert np.timedelta64(np.timedelta64(1, 'Y'), 'M') == np.timedelta64("12") assert np.timedelta64(np.timedelta64(1, 'Y'), 'D') == np.timedelta64("365") assert array_equal( np.timedelta64(1, 'Y') + np.int8(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(1, 'Y') + np.int16(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(1, 'Y') + np.int32(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(1, 'Y') + np.int64(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(21, 'Y') - np.uint8(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(21, 'Y') - np.uint16(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(21, 'Y') - np.uint32(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(21, 'Y') - np.uint64(10), np.timedelta64(11, 'Y')) assert array_equal( np.timedelta64(1, 'Y') + 0x12AF, np.timedelta64(4784, 'Y')) assert array_equal( np.timedelta64(1, 'h') * np.float(10.0), np.timedelta64(10, 'h')) assert array_equal( np.timedelta64(1, 'h') * np.float16(10.0), np.timedelta64(10, 'h')) assert array_equal( np.timedelta64(1, 'h') * np.float32(10.0), np.timedelta64(10, 'h')) assert array_equal( np.timedelta64(1, 's') / np.float(10.0), np.timedelta64(0, 's')) assert array_equal( np.timedelta64(1, 's') / np.float16(10.0), np.timedelta64(0, 's')) assert array_equal( np.timedelta64(1, 's') / np.float32(10.0), np.timedelta64(0, 's')) assert array_equal( np.timedelta64(1, 's') / np.double(10.0), np.timedelta64(0, 's')) assert np.datetime64('2005-02-25') == np.datetime64( "2005-02-25T00:00:00.000000") assert np.datetime64('2005-02') == np.datetime64( "2005-02-01T00:00:00.000000") assert np.datetime64(1, 'Y') == np.datetime64("1971") assert np.datetime64('2005-02-25T03:30') == np.datetime64( "2005-02-25T03:30:00.000000") assert (np.array(['2001-01-01T12:00', '2002-02-03T13:56:03.172'], dtype='datetime64') == np.array( ["2001-01-01T12:00", "2002-02-03T13:56:03.172"])).all() assert (np.array([0, 1577836800], dtype='datetime64[s]') == np.array(["0", "1577836800"])).all() assert (np.datetime64('2009-01-01') - np.datetime64('2008-01-01')) == np.timedelta64(366, "D") assert ( np.datetime64('2009') + np.timedelta64(20, 'D')) == np.datetime64('2009-01-21T00:00:00.000000') assert ( np.datetime64('2011-06-15T00:00') + np.timedelta64(12, 'h')) == np.datetime64('2011-06-15T12:00:00.000000') assert (np.timedelta64(1, 'W') / np.timedelta64(1, 'D')) == 7 assert (np.timedelta64(1, 'W') % np.timedelta64(10, 'D')) == np.timedelta64(7, "D") assert np.isnat(np.datetime64('nat') - np.datetime64('2009-01-01')) assert np.isnat(np.datetime64('2009-01-01') + np.timedelta64('nat')) assert (np.datetime64('2010-01-01') - np.datetime64('2008-01-01')) == np.timedelta64(731, "D") assert (np.datetime64('2010-01-01T04:30') - np.datetime64('2008-01-01T05:30')) == np.timedelta64(1052580, "m") assert (np.datetime64('2009', 'Y') - np.datetime64('2010', 'Y')) == np.timedelta64(-1, "Y") assert (np.timedelta64(4, 'h') + np.timedelta64(30, 'D')) == np.timedelta64(724, "h") assert (np.timedelta64(4, 'h') + np.timedelta64(30, 'ns')) == np.timedelta64(14400000000030, "ns") assert (np.timedelta64(2, 'W') / np.timedelta64(1, 'D')) == 14 assert (np.timedelta64(2, 'W') % np.timedelta64(11, 'D')) == np.timedelta64(3, "D") assert (np.timedelta64(3, 'W') % np.timedelta64(12, 'D')) == np.timedelta64(9, "D") assert (np.datetime64('2010-01-01') - np.datetime64('2012-01-01')) == np.timedelta64(-730, "D") assert (np.datetime64('2011-06-15T03:00') - np.datetime64('2019-11-01')) == np.timedelta64(-4407660, "m") assert (np.timedelta64(1, 'W') / np.timedelta64(-8, 'D')) == -0.875 assert (np.timedelta64(2, 'W') % np.timedelta64(15, 'D')) == np.timedelta64(14, "D") assert (np.datetime64('2022-01-01', 'D') + 5) == np.datetime64("2022-01-06") assert (np.datetime64('2022-01-10', 'D') - 3) == np.datetime64("2022-01-07") assert (np.datetime64('2022-01-05', 'D') + 2) == np.datetime64("2022-01-07") assert (np.datetime64('2022-01-10', 'D') - 9) == np.datetime64("2022-01-01") assert (np.datetime64('2022-01-01T12:00', 's') + 3) == np.datetime64("2022-01-01T12:00:03") assert (np.datetime64('2022-01-01T12:00', 'ns') + 67) == np.datetime64( "2022-01-01T12:00:00.000000067", 'ns') assert (np.datetime64('2022-01-10T10:45', 'm') - 5) == np.datetime64("2022-01-10T10:40") assert (np.datetime64('2022-01-01', 'Y') + np.byte(5)) == np.datetime64("2027") assert (np.datetime64('2022-01-01', 'Y') + np.ubyte(5)) == np.datetime64("2027") assert (np.datetime64('2022-01-01', 'M') - np.short(4)) == np.datetime64("2021-09") assert (np.datetime64('2022-01-01', 'M') - np.ushort(3)) == np.datetime64("2021-10") assert (np.datetime64('2022-01-01', 'D') + np.intc(5)) == np.datetime64("2022-01-06") assert (np.datetime64('2022-01-01', 'D') + np.int_(7)) == np.datetime64("2022-01-08") assert (np.datetime64('2022-01-01', 'Y') - np.uint(3)) == np.datetime64("2019") assert (np.datetime64('2022-01-01', 'D') + np.longlong(2)) == np.datetime64("2022-01-03") assert (np.datetime64('2022-01-01', 'W') + np.ulonglong(7)) == np.datetime64("2022-02-17") assert (np.datetime64('2022-01-01', 'W') + np.int8(74)) == np.datetime64("2023-06-01") x = np.array(['1910-08-16', '1910-08-11', '1910-08-10'], dtype=np.datetime64['Y', 1]) assert array_equal(x - np.array([6, -1, 4], dtype=np.datetime64['Y', 1]), np.array([-66, -59, -64], dtype=np.datetime64['Y', 1])) assert array_equal( x - np.array(['2022-01-23', '2022-01-23', '2022-01-23'], dtype=np.datetime64['Y', 1]), np.array([-112, -112, -112], dtype=np.datetime64['Y', 1])) assert array_equal(x - np.array([-5, -3, 0], dtype=np.datetime64['D', 1]), np.array([-21910, -21912, -21915])) assert array_equal( x - np.array(['2019-01-23', '2020-11-06', '1998-08-23'], dtype=np.datetime64['D', 1]), np.array([-39834, -40487, -32376])) assert array_equal( x - np.array(['2019-01-23', '2020-11-06', '1998-08-23'], dtype=np.datetime64['s', 1]), np.array([-3441657600, -3498076800, -2797286400])) x = np.array(['2002-10-27', '2002-10-27', '2002-10-27', '2002-10-27'], dtype=np.datetime64['m', 1]) assert (np.datetime_as_string(x, timezone='UTC') == np.array([ '2002-10-27T00:00Z', '2002-10-27T00:00Z', '2002-10-27T00:00Z', '2002-10-27T00:00Z' ])).all() assert (np.datetime_as_string(x, unit='h') == np.array( ['2002-10-27T00', '2002-10-27T00', '2002-10-27T00', '2002-10-27T00'])).all() assert (np.datetime_as_string(x, unit='s') == np.array([ '2002-10-27T00:00:00', '2002-10-27T00:00:00', '2002-10-27T00:00:00', '2002-10-27T00:00:00' ])).all() test_datetime64() @test def test_busday_offset(): assert array_equal(np.busday_offset('2011-10', 0, roll='forward'), np.datetime64['D', 1]('2011-10-03')) assert array_equal(np.busday_offset('2012-03', -1, roll='forward'), np.datetime64['D', 1]('2012-02-29')) assert array_equal( np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed'), np.datetime64['D', 1]('2011-01-19')) assert array_equal( np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun'), np.datetime64['D', 1]('2012-05-13')) assert array_equal(np.busday_offset('2011-03-20', 0, roll='forward'), np.datetime64['D', 1]('2011-03-21')) assert array_equal(np.busday_offset('2011-03-22', 0, roll='forward'), np.datetime64['D', 1]('2011-03-22')) assert array_equal(np.busday_offset('2011-03-20', 1, roll='backward'), np.datetime64['D', 1]('2011-03-21')) assert array_equal(np.busday_offset('2011-03-22', 1, roll='backward'), np.datetime64['D', 1]('2011-03-23')) test_busday_offset() @test def test_is_busday(): assert array_equal( np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], holidays=['2011-07-01', '2011-07-04', '2011-07-17']), np.array([False, False, True])) assert array_equal(np.is_busday("2012"), False) assert array_equal(np.is_busday(["2012"]), np.array([False])) assert array_equal( np.is_busday( np.array([ '2022-02-14', '2022-02-15', '2022-02-16', '2022-02-17', '2022-02-18' ], dtype=datetime64['D', 1])), np.array([True, True, True, True, True])) assert array_equal( np.is_busday( np.array(['2022-02-19', '2022-02-20'], dtype=datetime64['D', 1])), np.array([False, False])) assert array_equal( np.is_busday(np.array([ '2022-02-14', '2022-02-15', '2022-02-16', '2022-02-17', '2022-02-18' ], dtype=datetime64['D', 1]), holidays=np.array(['2022-02-17'], dtype=datetime64['D', 1])), np.array([True, True, True, False, True])) assert array_equal( np.is_busday(np.array([ '2022-02-14', '2022-02-15', '2022-02-16', '2022-02-17', '2022-02-18' ], dtype=datetime64['D', 1]), weekmask='1111000'), np.array([True, True, True, True, False])) assert array_equal( np.is_busday(np.array([ '2022-02-14', '2022-02-15', '2022-02-16', '2022-02-17', '2022-02-18' ], dtype=datetime64['D', 1]), holidays=np.array(['2022-02-17'], dtype=datetime64['D', 1]), weekmask='1111000'), np.array([True, True, True, False, False])) test_is_busday() @test def test_busday_count(): assert array_equal(np.busday_count('2022-02-14', '2022-02-18'), 4) assert array_equal(np.busday_count('2022-02-18', '2022-02-14'), -4) assert array_equal( np.busday_count('2022-02-14', '2022-02-18', holidays=['2022-02-16']), 3) assert array_equal( np.busday_count('2022-02-14', '2022-02-18', weekmask='1111000'), 4) assert array_equal( np.busday_count('2022-02-14', '2022-02-18', busdaycal=np.busdaycalendar(weekmask='1111100', holidays=['2022-02-16'])), 3) assert array_equal( np.busday_count('2022-02-14', '2022-02-18', out=np.array(0)), np.array(4)) begindates = '2022-02-14' enddates = '2022-02-18' test_busday_count() @test def test_datetime_data(): assert np.datetime_data(np.datetime64['Y', 1]) == ('Y', 1) assert np.datetime_data(np.datetime64['M', 1]) == ('M', 1) assert np.datetime_data(np.datetime64['W', 1]) == ('W', 1) assert np.datetime_data(np.datetime64['D', 1]) == ('D', 1) assert np.datetime_data(np.datetime64['h', 1]) == ('h', 1) assert np.datetime_data(np.datetime64['m', 1]) == ('m', 1) assert np.datetime_data(np.datetime64['s', 1]) == ('s', 1) assert np.datetime_data(np.timedelta64['D', 1]) == ('D', 1) assert np.datetime_data(np.timedelta64['h', 1]) == ('h', 1) assert np.datetime_data(np.timedelta64['m', 1]) == ('m', 1) assert np.datetime_data(np.timedelta64['s', 1]) == ('s', 1) test_datetime_data() @test def test_datetime_as_string(): assert array_equal( np.datetime_as_string( np.array(['2022-02-14T12:34:56', '2022-02-15T08:45:30'], dtype=datetime64['s', 1])), np.array(['2022-02-14T12:34:56', '2022-02-15T08:45:30'])) arr = np.array(['2022-02-14T12:34:56', '2022-02-15T08:45:30'], dtype=datetime64['Y', 1]) result = np.datetime_as_string(arr, unit='Y', timezone='UTC') x = np.array(['2002-10-27', '2002-10-27', '2002-10-27', '2002-10-27'], dtype=np.datetime64['m', 1]) assert (np.datetime_as_string(x, timezone='UTC') == np.array([ '2002-10-27T00:00Z', '2002-10-27T00:00Z', '2002-10-27T00:00Z', '2002-10-27T00:00Z' ])).all() assert (np.datetime_as_string(x, unit='h') == np.array( ['2002-10-27T00', '2002-10-27T00', '2002-10-27T00', '2002-10-27T00'])).all() assert (np.datetime_as_string(x, unit='s') == np.array([ '2002-10-27T00:00:00', '2002-10-27T00:00:00', '2002-10-27T00:00:00', '2002-10-27T00:00:00' ])).all() test_datetime_as_string() @test def test_datetime_timedelta_op(): assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'Y'), np.datetime64['Y', 1]('2029')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'M'), np.datetime64['M', 1]('2010-09')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'W'), np.datetime64['W', 1]('2009-05-21')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'D'), np.datetime64['D', 1]('2009-01-21')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'h'), np.datetime64['h', 1]('2009-01-01T20')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 'm'), np.datetime64['m', 1]('2009-01-01T00:20')) assert array_equal( np.datetime64('2009', 'Y') + np.timedelta64(20, 's'), np.datetime64['s', 1]('2009-01-01T00:00:20')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'Y'), np.datetime64['Y', 1]('1989')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'M'), np.datetime64['M', 1]('2007-05')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'W'), np.datetime64['W', 1]('2008-08-14')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'D'), np.datetime64['D', 1]('2008-12-12')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'h'), np.datetime64['h', 1]('2008-12-31T04')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 'm'), np.datetime64['m', 1]('2008-12-31T23:40')) assert array_equal( np.datetime64('2009', 'Y') - np.timedelta64(20, 's'), np.datetime64['s', 1]('2008-12-31T23:59:40')) x = np.array(['1910-08-16', '1910-08-11', '1910-08-10'], dtype=np.datetime64['Y', 1]) assert array_equal( x + np.array([-5, -3, 0], dtype=np.timedelta64['Y', 1]), np.array(['1905', '1907', '1910'], dtype=np.datetime64['Y', 1])) assert array_equal( x + np.array([-5, -3, 0], dtype=np.timedelta64['M', 1]), np.array(['1909-08', '1909-10', '1910-01'], dtype=np.datetime64['M', 1])) assert array_equal( x + np.array([-5, -3, 0], dtype=np.timedelta64['D', 1]), np.array(['1909-12-27', '1909-12-29', '1910-01-01'], dtype=np.datetime64['D', 1])) assert array_equal( x - np.array([-5, -3, 0], dtype=np.timedelta64['Y', 1]), np.array(['1915', '1913', '1910'], dtype=np.datetime64['Y', 1])) assert array_equal( x - np.array([-5, -3, 0], dtype=np.timedelta64['M', 1]), np.array(['1910-06', '1910-04', '1910-01'], dtype=np.datetime64['M', 1])) assert array_equal( x - np.array([-5, -3, 0], dtype=np.timedelta64['D', 1]), np.array(['1910-01-06', '1910-01-04', '1910-01-01'], dtype=np.datetime64['D', 1])) assert array_equal(np.timedelta64(1, 'Y') + 10, np.timedelta64(11, 'Y')) assert array_equal(np.timedelta64(1, 'Y') - 10, np.timedelta64(-9, 'Y')) assert array_equal(np.timedelta64(1, 'Y') * 10, np.timedelta64(10, 'Y')) assert array_equal(np.timedelta64(1, 'Y') / 10, np.timedelta64(0, 'Y')) assert array_equal(np.timedelta64(1, 'Y') * 10.0, np.timedelta64(10, 'Y')) assert array_equal(np.timedelta64(1, 'Y') / 10.0, np.timedelta64(0, 'Y')) assert array_equal(np.timedelta64(1, 'M') + 10, np.timedelta64(11, 'M')) assert array_equal(np.timedelta64(1, 'D') - 10, np.timedelta64(-9, 'D')) assert array_equal(np.timedelta64(1, 'h') * 10, np.timedelta64(10, 'h')) assert array_equal(np.timedelta64(1, 's') / 10, np.timedelta64(0, 's')) assert array_equal(np.timedelta64(1, 'h') * 10.0, np.timedelta64(10, 'h')) assert array_equal(np.timedelta64(1, 's') / 10.0, np.timedelta64(0, 's')) test_datetime_timedelta_op() @test def test_busdaycalender(): assert array_equal((np.busdaycalendar()).weekmask, np.array([True, True, True, True, True, False, False])) assert array_equal( (np.busdaycalendar(holidays=['2022-02-16', '2022-05-01'])).weekmask, np.array([True, True, True, True, True, False, False])) assert array_equal( (np.busdaycalendar(holidays=['2022-02-16', '2022-05-01'])).holidays, np.array(['2022-02-16'], dtype=np.datetime64['D', 1])) holidays = '2024-02-14', np.datetime64('NaT') assert array_equal((np.busdaycalendar(holidays=holidays)).holidays, np.array(['2024-02-14'], dtype=np.datetime64['D', 1])) assert array_equal( (np.busdaycalendar(holidays=['2022-02-16', '2022-05-01'], weekmask='0011111')).holidays, np.array(['2022-02-16', '2022-05-01'], dtype=np.datetime64['D', 1])) assert array_equal( (np.busdaycalendar(weekmask='1100011', holidays=['2022-02-16', '2022-05-01']).weekmask), np.array([True, True, False, False, False, True, True])) test_busdaycalender() @test def miscellaneous(): assert np.busday_offset('2007-02-25', 11, weekmask='SatSun') == np.datetime64( '2007-04-07', 'D') assert np.busday_offset('2007-04-07', -11, weekmask='SatSun') == np.datetime64( '2007-02-25', 'D') bdd = np.busdaycalendar(weekmask="Sun TueWed Thu\tFri") assert np.array_equal(bdd.weekmask, np.array([0, 1, 1, 1, 1, 0, 1], dtype=bool)) assert np.busday_offset('2011-11-14', -1, holidays=['2011-11-11' ]) == np.datetime64('2011-11-10', 'D') assert np.busday_offset('2011-11-18', -5, holidays=['2011-11-11' ]) == np.datetime64('2011-11-10', 'D') assert np.busday_offset('2011-11-14', -5, holidays=['2011-11-11' ]) == np.datetime64('2011-11-04', 'D') assert np.busday_offset('2011-11-14', -1, holidays=['2011-11-11', '2011-11-11' ]) == np.datetime64('2011-11-10', 'D') # With a NaT holiday assert np.busday_offset('2011-11-14', -1, holidays=['NaT', '2011-11-11' ]) == np.datetime64('2011-11-10', 'D') # With another holiday after assert np.busday_offset('2011-11-14', -1, holidays=['2011-11-11', '2011-11-24' ]) == np.datetime64('2011-11-10', 'D') holidays = [ '2011-10-10', '2011-11-11', '2011-11-24', '2011-12-25', '2011-05-30', '2011-02-21', '2011-12-26', '2012-01-02' ] # With another holiday before assert np.busday_offset('2011-11-14', -1, holidays=['2011-10-10', '2011-11-11' ]) == np.datetime64('2011-11-10', 'D') assert np.busday_offset('2012-01-03', -1, holidays=holidays) == np.busday_offset( '2012-01-03', -1 - 1) assert np.busday_offset('2012-01-03', -4, holidays=holidays) == np.busday_offset( '2012-01-03', -4 - 1) assert np.busday_offset('2012-01-03', -5, holidays=holidays) == np.busday_offset( '2012-01-03', -5 - 2) assert np.busday_offset('2012-01-03', -25, holidays=holidays) == np.busday_offset( '2012-01-03', -25 - 2) assert np.busday_offset('2012-01-03', -26, holidays=holidays) == np.busday_offset( '2012-01-03', -26 - 3) assert np.busday_offset('2012-01-03', -33, holidays=holidays) == np.busday_offset( '2012-01-03', -33 - 3) assert np.busday_offset('2012-01-03', -34, holidays=holidays) == np.busday_offset( '2012-01-03', -34 - 4) assert np.busday_offset('2012-01-03', -56, holidays=holidays) == np.busday_offset( '2012-01-03', -56 - 4) assert np.busday_offset('2012-01-03', -57, holidays=holidays) == np.busday_offset( '2012-01-03', -57 - 5) miscellaneous()