test_datetime.py 107 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413
  1. import numpy
  2. import numpy as np
  3. import datetime
  4. import pytest
  5. from numpy.testing import (
  6. assert_, assert_equal, assert_raises, assert_warns, suppress_warnings,
  7. assert_raises_regex,
  8. )
  9. from numpy.compat import pickle
  10. # Use pytz to test out various time zones if available
  11. try:
  12. from pytz import timezone as tz
  13. _has_pytz = True
  14. except ImportError:
  15. _has_pytz = False
  16. try:
  17. RecursionError
  18. except NameError:
  19. RecursionError = RuntimeError # python < 3.5
  20. class TestDateTime:
  21. def test_datetime_dtype_creation(self):
  22. for unit in ['Y', 'M', 'W', 'D',
  23. 'h', 'm', 's', 'ms', 'us',
  24. 'μs', # alias for us
  25. 'ns', 'ps', 'fs', 'as']:
  26. dt1 = np.dtype('M8[750%s]' % unit)
  27. assert_(dt1 == np.dtype('datetime64[750%s]' % unit))
  28. dt2 = np.dtype('m8[%s]' % unit)
  29. assert_(dt2 == np.dtype('timedelta64[%s]' % unit))
  30. # Generic units shouldn't add [] to the end
  31. assert_equal(str(np.dtype("M8")), "datetime64")
  32. # Should be possible to specify the endianness
  33. assert_equal(np.dtype("=M8"), np.dtype("M8"))
  34. assert_equal(np.dtype("=M8[s]"), np.dtype("M8[s]"))
  35. assert_(np.dtype(">M8") == np.dtype("M8") or
  36. np.dtype("<M8") == np.dtype("M8"))
  37. assert_(np.dtype(">M8[D]") == np.dtype("M8[D]") or
  38. np.dtype("<M8[D]") == np.dtype("M8[D]"))
  39. assert_(np.dtype(">M8") != np.dtype("<M8"))
  40. assert_equal(np.dtype("=m8"), np.dtype("m8"))
  41. assert_equal(np.dtype("=m8[s]"), np.dtype("m8[s]"))
  42. assert_(np.dtype(">m8") == np.dtype("m8") or
  43. np.dtype("<m8") == np.dtype("m8"))
  44. assert_(np.dtype(">m8[D]") == np.dtype("m8[D]") or
  45. np.dtype("<m8[D]") == np.dtype("m8[D]"))
  46. assert_(np.dtype(">m8") != np.dtype("<m8"))
  47. # Check that the parser rejects bad datetime types
  48. assert_raises(TypeError, np.dtype, 'M8[badunit]')
  49. assert_raises(TypeError, np.dtype, 'm8[badunit]')
  50. assert_raises(TypeError, np.dtype, 'M8[YY]')
  51. assert_raises(TypeError, np.dtype, 'm8[YY]')
  52. assert_raises(TypeError, np.dtype, 'm4')
  53. assert_raises(TypeError, np.dtype, 'M7')
  54. assert_raises(TypeError, np.dtype, 'm7')
  55. assert_raises(TypeError, np.dtype, 'M16')
  56. assert_raises(TypeError, np.dtype, 'm16')
  57. def test_datetime_casting_rules(self):
  58. # Cannot cast safely/same_kind between timedelta and datetime
  59. assert_(not np.can_cast('m8', 'M8', casting='same_kind'))
  60. assert_(not np.can_cast('M8', 'm8', casting='same_kind'))
  61. assert_(not np.can_cast('m8', 'M8', casting='safe'))
  62. assert_(not np.can_cast('M8', 'm8', casting='safe'))
  63. # Can cast safely/same_kind from integer to timedelta
  64. assert_(np.can_cast('i8', 'm8', casting='same_kind'))
  65. assert_(np.can_cast('i8', 'm8', casting='safe'))
  66. assert_(np.can_cast('i4', 'm8', casting='same_kind'))
  67. assert_(np.can_cast('i4', 'm8', casting='safe'))
  68. assert_(np.can_cast('u4', 'm8', casting='same_kind'))
  69. assert_(np.can_cast('u4', 'm8', casting='safe'))
  70. # Cannot cast safely from unsigned integer of the same size, which
  71. # could overflow
  72. assert_(np.can_cast('u8', 'm8', casting='same_kind'))
  73. assert_(not np.can_cast('u8', 'm8', casting='safe'))
  74. # Cannot cast safely/same_kind from float to timedelta
  75. assert_(not np.can_cast('f4', 'm8', casting='same_kind'))
  76. assert_(not np.can_cast('f4', 'm8', casting='safe'))
  77. # Cannot cast safely/same_kind from integer to datetime
  78. assert_(not np.can_cast('i8', 'M8', casting='same_kind'))
  79. assert_(not np.can_cast('i8', 'M8', casting='safe'))
  80. # Cannot cast safely/same_kind from bool to datetime
  81. assert_(not np.can_cast('b1', 'M8', casting='same_kind'))
  82. assert_(not np.can_cast('b1', 'M8', casting='safe'))
  83. # Can cast safely/same_kind from bool to timedelta
  84. assert_(np.can_cast('b1', 'm8', casting='same_kind'))
  85. assert_(np.can_cast('b1', 'm8', casting='safe'))
  86. # Can cast datetime safely from months/years to days
  87. assert_(np.can_cast('M8[M]', 'M8[D]', casting='safe'))
  88. assert_(np.can_cast('M8[Y]', 'M8[D]', casting='safe'))
  89. # Cannot cast timedelta safely from months/years to days
  90. assert_(not np.can_cast('m8[M]', 'm8[D]', casting='safe'))
  91. assert_(not np.can_cast('m8[Y]', 'm8[D]', casting='safe'))
  92. # Can cast datetime same_kind from months/years to days
  93. assert_(np.can_cast('M8[M]', 'M8[D]', casting='same_kind'))
  94. assert_(np.can_cast('M8[Y]', 'M8[D]', casting='same_kind'))
  95. # Can't cast timedelta same_kind from months/years to days
  96. assert_(not np.can_cast('m8[M]', 'm8[D]', casting='same_kind'))
  97. assert_(not np.can_cast('m8[Y]', 'm8[D]', casting='same_kind'))
  98. # Can cast datetime same_kind across the date/time boundary
  99. assert_(np.can_cast('M8[D]', 'M8[h]', casting='same_kind'))
  100. # Can cast timedelta same_kind across the date/time boundary
  101. assert_(np.can_cast('m8[D]', 'm8[h]', casting='same_kind'))
  102. assert_(np.can_cast('m8[h]', 'm8[D]', casting='same_kind'))
  103. # Cannot cast safely if the integer multiplier doesn't divide
  104. assert_(not np.can_cast('M8[7h]', 'M8[3h]', casting='safe'))
  105. assert_(not np.can_cast('M8[3h]', 'M8[6h]', casting='safe'))
  106. # But can cast same_kind
  107. assert_(np.can_cast('M8[7h]', 'M8[3h]', casting='same_kind'))
  108. # Can cast safely if the integer multiplier does divide
  109. assert_(np.can_cast('M8[6h]', 'M8[3h]', casting='safe'))
  110. # We can always cast types with generic units (corresponding to NaT) to
  111. # more specific types
  112. assert_(np.can_cast('m8', 'm8[h]', casting='same_kind'))
  113. assert_(np.can_cast('m8', 'm8[h]', casting='safe'))
  114. assert_(np.can_cast('M8', 'M8[h]', casting='same_kind'))
  115. assert_(np.can_cast('M8', 'M8[h]', casting='safe'))
  116. # but not the other way around
  117. assert_(not np.can_cast('m8[h]', 'm8', casting='same_kind'))
  118. assert_(not np.can_cast('m8[h]', 'm8', casting='safe'))
  119. assert_(not np.can_cast('M8[h]', 'M8', casting='same_kind'))
  120. assert_(not np.can_cast('M8[h]', 'M8', casting='safe'))
  121. def test_compare_generic_nat(self):
  122. # regression tests for gh-6452
  123. assert_(np.datetime64('NaT') !=
  124. np.datetime64('2000') + np.timedelta64('NaT'))
  125. assert_(np.datetime64('NaT') != np.datetime64('NaT', 'us'))
  126. assert_(np.datetime64('NaT', 'us') != np.datetime64('NaT'))
  127. @pytest.mark.parametrize("size", [
  128. 3, 21, 217, 1000])
  129. def test_datetime_nat_argsort_stability(self, size):
  130. # NaT < NaT should be False internally for
  131. # sort stability
  132. expected = np.arange(size)
  133. arr = np.tile(np.datetime64('NaT'), size)
  134. assert_equal(np.argsort(arr, kind='mergesort'), expected)
  135. @pytest.mark.parametrize("size", [
  136. 3, 21, 217, 1000])
  137. def test_timedelta_nat_argsort_stability(self, size):
  138. # NaT < NaT should be False internally for
  139. # sort stability
  140. expected = np.arange(size)
  141. arr = np.tile(np.timedelta64('NaT'), size)
  142. assert_equal(np.argsort(arr, kind='mergesort'), expected)
  143. @pytest.mark.parametrize("arr, expected", [
  144. # the example provided in gh-12629
  145. (['NaT', 1, 2, 3],
  146. [1, 2, 3, 'NaT']),
  147. # multiple NaTs
  148. (['NaT', 9, 'NaT', -707],
  149. [-707, 9, 'NaT', 'NaT']),
  150. # this sort explores another code path for NaT
  151. ([1, -2, 3, 'NaT'],
  152. [-2, 1, 3, 'NaT']),
  153. # 2-D array
  154. ([[51, -220, 'NaT'],
  155. [-17, 'NaT', -90]],
  156. [[-220, 51, 'NaT'],
  157. [-90, -17, 'NaT']]),
  158. ])
  159. @pytest.mark.parametrize("dtype", [
  160. 'M8[ns]', 'M8[us]',
  161. 'm8[ns]', 'm8[us]'])
  162. def test_datetime_timedelta_sort_nat(self, arr, expected, dtype):
  163. # fix for gh-12629 and gh-15063; NaT sorting to end of array
  164. arr = np.array(arr, dtype=dtype)
  165. expected = np.array(expected, dtype=dtype)
  166. arr.sort()
  167. assert_equal(arr, expected)
  168. def test_datetime_scalar_construction(self):
  169. # Construct with different units
  170. assert_equal(np.datetime64('1950-03-12', 'D'),
  171. np.datetime64('1950-03-12'))
  172. assert_equal(np.datetime64('1950-03-12T13', 's'),
  173. np.datetime64('1950-03-12T13', 'm'))
  174. # Default construction means NaT
  175. assert_equal(np.datetime64(), np.datetime64('NaT'))
  176. # Some basic strings and repr
  177. assert_equal(str(np.datetime64('NaT')), 'NaT')
  178. assert_equal(repr(np.datetime64('NaT')),
  179. "numpy.datetime64('NaT')")
  180. assert_equal(str(np.datetime64('2011-02')), '2011-02')
  181. assert_equal(repr(np.datetime64('2011-02')),
  182. "numpy.datetime64('2011-02')")
  183. # None gets constructed as NaT
  184. assert_equal(np.datetime64(None), np.datetime64('NaT'))
  185. # Default construction of NaT is in generic units
  186. assert_equal(np.datetime64().dtype, np.dtype('M8'))
  187. assert_equal(np.datetime64('NaT').dtype, np.dtype('M8'))
  188. # Construction from integers requires a specified unit
  189. assert_raises(ValueError, np.datetime64, 17)
  190. # When constructing from a scalar or zero-dimensional array,
  191. # it either keeps the units or you can override them.
  192. a = np.datetime64('2000-03-18T16', 'h')
  193. b = np.array('2000-03-18T16', dtype='M8[h]')
  194. assert_equal(a.dtype, np.dtype('M8[h]'))
  195. assert_equal(b.dtype, np.dtype('M8[h]'))
  196. assert_equal(np.datetime64(a), a)
  197. assert_equal(np.datetime64(a).dtype, np.dtype('M8[h]'))
  198. assert_equal(np.datetime64(b), a)
  199. assert_equal(np.datetime64(b).dtype, np.dtype('M8[h]'))
  200. assert_equal(np.datetime64(a, 's'), a)
  201. assert_equal(np.datetime64(a, 's').dtype, np.dtype('M8[s]'))
  202. assert_equal(np.datetime64(b, 's'), a)
  203. assert_equal(np.datetime64(b, 's').dtype, np.dtype('M8[s]'))
  204. # Construction from datetime.date
  205. assert_equal(np.datetime64('1945-03-25'),
  206. np.datetime64(datetime.date(1945, 3, 25)))
  207. assert_equal(np.datetime64('2045-03-25', 'D'),
  208. np.datetime64(datetime.date(2045, 3, 25), 'D'))
  209. # Construction from datetime.datetime
  210. assert_equal(np.datetime64('1980-01-25T14:36:22.5'),
  211. np.datetime64(datetime.datetime(1980, 1, 25,
  212. 14, 36, 22, 500000)))
  213. # Construction with time units from a date is okay
  214. assert_equal(np.datetime64('1920-03-13', 'h'),
  215. np.datetime64('1920-03-13T00'))
  216. assert_equal(np.datetime64('1920-03', 'm'),
  217. np.datetime64('1920-03-01T00:00'))
  218. assert_equal(np.datetime64('1920', 's'),
  219. np.datetime64('1920-01-01T00:00:00'))
  220. assert_equal(np.datetime64(datetime.date(2045, 3, 25), 'ms'),
  221. np.datetime64('2045-03-25T00:00:00.000'))
  222. # Construction with date units from a datetime is also okay
  223. assert_equal(np.datetime64('1920-03-13T18', 'D'),
  224. np.datetime64('1920-03-13'))
  225. assert_equal(np.datetime64('1920-03-13T18:33:12', 'M'),
  226. np.datetime64('1920-03'))
  227. assert_equal(np.datetime64('1920-03-13T18:33:12.5', 'Y'),
  228. np.datetime64('1920'))
  229. def test_datetime_scalar_construction_timezone(self):
  230. # verify that supplying an explicit timezone works, but is deprecated
  231. with assert_warns(DeprecationWarning):
  232. assert_equal(np.datetime64('2000-01-01T00Z'),
  233. np.datetime64('2000-01-01T00'))
  234. with assert_warns(DeprecationWarning):
  235. assert_equal(np.datetime64('2000-01-01T00-08'),
  236. np.datetime64('2000-01-01T08'))
  237. def test_datetime_array_find_type(self):
  238. dt = np.datetime64('1970-01-01', 'M')
  239. arr = np.array([dt])
  240. assert_equal(arr.dtype, np.dtype('M8[M]'))
  241. # at the moment, we don't automatically convert these to datetime64
  242. dt = datetime.date(1970, 1, 1)
  243. arr = np.array([dt])
  244. assert_equal(arr.dtype, np.dtype('O'))
  245. dt = datetime.datetime(1970, 1, 1, 12, 30, 40)
  246. arr = np.array([dt])
  247. assert_equal(arr.dtype, np.dtype('O'))
  248. # find "supertype" for non-dates and dates
  249. b = np.bool_(True)
  250. dm = np.datetime64('1970-01-01', 'M')
  251. d = datetime.date(1970, 1, 1)
  252. dt = datetime.datetime(1970, 1, 1, 12, 30, 40)
  253. arr = np.array([b, dm])
  254. assert_equal(arr.dtype, np.dtype('O'))
  255. arr = np.array([b, d])
  256. assert_equal(arr.dtype, np.dtype('O'))
  257. arr = np.array([b, dt])
  258. assert_equal(arr.dtype, np.dtype('O'))
  259. arr = np.array([d, d]).astype('datetime64')
  260. assert_equal(arr.dtype, np.dtype('M8[D]'))
  261. arr = np.array([dt, dt]).astype('datetime64')
  262. assert_equal(arr.dtype, np.dtype('M8[us]'))
  263. @pytest.mark.parametrize("unit", [
  264. # test all date / time units and use
  265. # "generic" to select generic unit
  266. ("Y"), ("M"), ("W"), ("D"), ("h"), ("m"),
  267. ("s"), ("ms"), ("us"), ("ns"), ("ps"),
  268. ("fs"), ("as"), ("generic") ])
  269. def test_timedelta_np_int_construction(self, unit):
  270. # regression test for gh-7617
  271. if unit != "generic":
  272. assert_equal(np.timedelta64(np.int64(123), unit),
  273. np.timedelta64(123, unit))
  274. else:
  275. assert_equal(np.timedelta64(np.int64(123)),
  276. np.timedelta64(123))
  277. def test_timedelta_scalar_construction(self):
  278. # Construct with different units
  279. assert_equal(np.timedelta64(7, 'D'),
  280. np.timedelta64(1, 'W'))
  281. assert_equal(np.timedelta64(120, 's'),
  282. np.timedelta64(2, 'm'))
  283. # Default construction means 0
  284. assert_equal(np.timedelta64(), np.timedelta64(0))
  285. # None gets constructed as NaT
  286. assert_equal(np.timedelta64(None), np.timedelta64('NaT'))
  287. # Some basic strings and repr
  288. assert_equal(str(np.timedelta64('NaT')), 'NaT')
  289. assert_equal(repr(np.timedelta64('NaT')),
  290. "numpy.timedelta64('NaT')")
  291. assert_equal(str(np.timedelta64(3, 's')), '3 seconds')
  292. assert_equal(repr(np.timedelta64(-3, 's')),
  293. "numpy.timedelta64(-3,'s')")
  294. assert_equal(repr(np.timedelta64(12)),
  295. "numpy.timedelta64(12)")
  296. # Construction from an integer produces generic units
  297. assert_equal(np.timedelta64(12).dtype, np.dtype('m8'))
  298. # When constructing from a scalar or zero-dimensional array,
  299. # it either keeps the units or you can override them.
  300. a = np.timedelta64(2, 'h')
  301. b = np.array(2, dtype='m8[h]')
  302. assert_equal(a.dtype, np.dtype('m8[h]'))
  303. assert_equal(b.dtype, np.dtype('m8[h]'))
  304. assert_equal(np.timedelta64(a), a)
  305. assert_equal(np.timedelta64(a).dtype, np.dtype('m8[h]'))
  306. assert_equal(np.timedelta64(b), a)
  307. assert_equal(np.timedelta64(b).dtype, np.dtype('m8[h]'))
  308. assert_equal(np.timedelta64(a, 's'), a)
  309. assert_equal(np.timedelta64(a, 's').dtype, np.dtype('m8[s]'))
  310. assert_equal(np.timedelta64(b, 's'), a)
  311. assert_equal(np.timedelta64(b, 's').dtype, np.dtype('m8[s]'))
  312. # Construction from datetime.timedelta
  313. assert_equal(np.timedelta64(5, 'D'),
  314. np.timedelta64(datetime.timedelta(days=5)))
  315. assert_equal(np.timedelta64(102347621, 's'),
  316. np.timedelta64(datetime.timedelta(seconds=102347621)))
  317. assert_equal(np.timedelta64(-10234760000, 'us'),
  318. np.timedelta64(datetime.timedelta(
  319. microseconds=-10234760000)))
  320. assert_equal(np.timedelta64(10234760000, 'us'),
  321. np.timedelta64(datetime.timedelta(
  322. microseconds=10234760000)))
  323. assert_equal(np.timedelta64(1023476, 'ms'),
  324. np.timedelta64(datetime.timedelta(milliseconds=1023476)))
  325. assert_equal(np.timedelta64(10, 'm'),
  326. np.timedelta64(datetime.timedelta(minutes=10)))
  327. assert_equal(np.timedelta64(281, 'h'),
  328. np.timedelta64(datetime.timedelta(hours=281)))
  329. assert_equal(np.timedelta64(28, 'W'),
  330. np.timedelta64(datetime.timedelta(weeks=28)))
  331. # Cannot construct across nonlinear time unit boundaries
  332. a = np.timedelta64(3, 's')
  333. assert_raises(TypeError, np.timedelta64, a, 'M')
  334. assert_raises(TypeError, np.timedelta64, a, 'Y')
  335. a = np.timedelta64(6, 'M')
  336. assert_raises(TypeError, np.timedelta64, a, 'D')
  337. assert_raises(TypeError, np.timedelta64, a, 'h')
  338. a = np.timedelta64(1, 'Y')
  339. assert_raises(TypeError, np.timedelta64, a, 'D')
  340. assert_raises(TypeError, np.timedelta64, a, 'm')
  341. a = datetime.timedelta(seconds=3)
  342. assert_raises(TypeError, np.timedelta64, a, 'M')
  343. assert_raises(TypeError, np.timedelta64, a, 'Y')
  344. a = datetime.timedelta(weeks=3)
  345. assert_raises(TypeError, np.timedelta64, a, 'M')
  346. assert_raises(TypeError, np.timedelta64, a, 'Y')
  347. a = datetime.timedelta()
  348. assert_raises(TypeError, np.timedelta64, a, 'M')
  349. assert_raises(TypeError, np.timedelta64, a, 'Y')
  350. def test_timedelta_object_array_conversion(self):
  351. # Regression test for gh-11096
  352. inputs = [datetime.timedelta(28),
  353. datetime.timedelta(30),
  354. datetime.timedelta(31)]
  355. expected = np.array([28, 30, 31], dtype='timedelta64[D]')
  356. actual = np.array(inputs, dtype='timedelta64[D]')
  357. assert_equal(expected, actual)
  358. def test_timedelta_0_dim_object_array_conversion(self):
  359. # Regression test for gh-11151
  360. test = np.array(datetime.timedelta(seconds=20))
  361. actual = test.astype(np.timedelta64)
  362. # expected value from the array constructor workaround
  363. # described in above issue
  364. expected = np.array(datetime.timedelta(seconds=20),
  365. np.timedelta64)
  366. assert_equal(actual, expected)
  367. def test_timedelta_nat_format(self):
  368. # gh-17552
  369. assert_equal('NaT', '{0}'.format(np.timedelta64('nat')))
  370. def test_timedelta_scalar_construction_units(self):
  371. # String construction detecting units
  372. assert_equal(np.datetime64('2010').dtype,
  373. np.dtype('M8[Y]'))
  374. assert_equal(np.datetime64('2010-03').dtype,
  375. np.dtype('M8[M]'))
  376. assert_equal(np.datetime64('2010-03-12').dtype,
  377. np.dtype('M8[D]'))
  378. assert_equal(np.datetime64('2010-03-12T17').dtype,
  379. np.dtype('M8[h]'))
  380. assert_equal(np.datetime64('2010-03-12T17:15').dtype,
  381. np.dtype('M8[m]'))
  382. assert_equal(np.datetime64('2010-03-12T17:15:08').dtype,
  383. np.dtype('M8[s]'))
  384. assert_equal(np.datetime64('2010-03-12T17:15:08.1').dtype,
  385. np.dtype('M8[ms]'))
  386. assert_equal(np.datetime64('2010-03-12T17:15:08.12').dtype,
  387. np.dtype('M8[ms]'))
  388. assert_equal(np.datetime64('2010-03-12T17:15:08.123').dtype,
  389. np.dtype('M8[ms]'))
  390. assert_equal(np.datetime64('2010-03-12T17:15:08.1234').dtype,
  391. np.dtype('M8[us]'))
  392. assert_equal(np.datetime64('2010-03-12T17:15:08.12345').dtype,
  393. np.dtype('M8[us]'))
  394. assert_equal(np.datetime64('2010-03-12T17:15:08.123456').dtype,
  395. np.dtype('M8[us]'))
  396. assert_equal(np.datetime64('1970-01-01T00:00:02.1234567').dtype,
  397. np.dtype('M8[ns]'))
  398. assert_equal(np.datetime64('1970-01-01T00:00:02.12345678').dtype,
  399. np.dtype('M8[ns]'))
  400. assert_equal(np.datetime64('1970-01-01T00:00:02.123456789').dtype,
  401. np.dtype('M8[ns]'))
  402. assert_equal(np.datetime64('1970-01-01T00:00:02.1234567890').dtype,
  403. np.dtype('M8[ps]'))
  404. assert_equal(np.datetime64('1970-01-01T00:00:02.12345678901').dtype,
  405. np.dtype('M8[ps]'))
  406. assert_equal(np.datetime64('1970-01-01T00:00:02.123456789012').dtype,
  407. np.dtype('M8[ps]'))
  408. assert_equal(np.datetime64(
  409. '1970-01-01T00:00:02.1234567890123').dtype,
  410. np.dtype('M8[fs]'))
  411. assert_equal(np.datetime64(
  412. '1970-01-01T00:00:02.12345678901234').dtype,
  413. np.dtype('M8[fs]'))
  414. assert_equal(np.datetime64(
  415. '1970-01-01T00:00:02.123456789012345').dtype,
  416. np.dtype('M8[fs]'))
  417. assert_equal(np.datetime64(
  418. '1970-01-01T00:00:02.1234567890123456').dtype,
  419. np.dtype('M8[as]'))
  420. assert_equal(np.datetime64(
  421. '1970-01-01T00:00:02.12345678901234567').dtype,
  422. np.dtype('M8[as]'))
  423. assert_equal(np.datetime64(
  424. '1970-01-01T00:00:02.123456789012345678').dtype,
  425. np.dtype('M8[as]'))
  426. # Python date object
  427. assert_equal(np.datetime64(datetime.date(2010, 4, 16)).dtype,
  428. np.dtype('M8[D]'))
  429. # Python datetime object
  430. assert_equal(np.datetime64(
  431. datetime.datetime(2010, 4, 16, 13, 45, 18)).dtype,
  432. np.dtype('M8[us]'))
  433. # 'today' special value
  434. assert_equal(np.datetime64('today').dtype,
  435. np.dtype('M8[D]'))
  436. # 'now' special value
  437. assert_equal(np.datetime64('now').dtype,
  438. np.dtype('M8[s]'))
  439. def test_datetime_nat_casting(self):
  440. a = np.array('NaT', dtype='M8[D]')
  441. b = np.datetime64('NaT', '[D]')
  442. # Arrays
  443. assert_equal(a.astype('M8[s]'), np.array('NaT', dtype='M8[s]'))
  444. assert_equal(a.astype('M8[ms]'), np.array('NaT', dtype='M8[ms]'))
  445. assert_equal(a.astype('M8[M]'), np.array('NaT', dtype='M8[M]'))
  446. assert_equal(a.astype('M8[Y]'), np.array('NaT', dtype='M8[Y]'))
  447. assert_equal(a.astype('M8[W]'), np.array('NaT', dtype='M8[W]'))
  448. # Scalars -> Scalars
  449. assert_equal(np.datetime64(b, '[s]'), np.datetime64('NaT', '[s]'))
  450. assert_equal(np.datetime64(b, '[ms]'), np.datetime64('NaT', '[ms]'))
  451. assert_equal(np.datetime64(b, '[M]'), np.datetime64('NaT', '[M]'))
  452. assert_equal(np.datetime64(b, '[Y]'), np.datetime64('NaT', '[Y]'))
  453. assert_equal(np.datetime64(b, '[W]'), np.datetime64('NaT', '[W]'))
  454. # Arrays -> Scalars
  455. assert_equal(np.datetime64(a, '[s]'), np.datetime64('NaT', '[s]'))
  456. assert_equal(np.datetime64(a, '[ms]'), np.datetime64('NaT', '[ms]'))
  457. assert_equal(np.datetime64(a, '[M]'), np.datetime64('NaT', '[M]'))
  458. assert_equal(np.datetime64(a, '[Y]'), np.datetime64('NaT', '[Y]'))
  459. assert_equal(np.datetime64(a, '[W]'), np.datetime64('NaT', '[W]'))
  460. # NaN -> NaT
  461. nan = np.array([np.nan] * 8)
  462. fnan = nan.astype('f')
  463. lnan = nan.astype('g')
  464. cnan = nan.astype('D')
  465. cfnan = nan.astype('F')
  466. clnan = nan.astype('G')
  467. nat = np.array([np.datetime64('NaT')] * 8)
  468. assert_equal(nan.astype('M8[ns]'), nat)
  469. assert_equal(fnan.astype('M8[ns]'), nat)
  470. assert_equal(lnan.astype('M8[ns]'), nat)
  471. assert_equal(cnan.astype('M8[ns]'), nat)
  472. assert_equal(cfnan.astype('M8[ns]'), nat)
  473. assert_equal(clnan.astype('M8[ns]'), nat)
  474. nat = np.array([np.timedelta64('NaT')] * 8)
  475. assert_equal(nan.astype('timedelta64[ns]'), nat)
  476. assert_equal(fnan.astype('timedelta64[ns]'), nat)
  477. assert_equal(lnan.astype('timedelta64[ns]'), nat)
  478. assert_equal(cnan.astype('timedelta64[ns]'), nat)
  479. assert_equal(cfnan.astype('timedelta64[ns]'), nat)
  480. assert_equal(clnan.astype('timedelta64[ns]'), nat)
  481. def test_days_creation(self):
  482. assert_equal(np.array('1599', dtype='M8[D]').astype('i8'),
  483. (1600-1970)*365 - (1972-1600)/4 + 3 - 365)
  484. assert_equal(np.array('1600', dtype='M8[D]').astype('i8'),
  485. (1600-1970)*365 - (1972-1600)/4 + 3)
  486. assert_equal(np.array('1601', dtype='M8[D]').astype('i8'),
  487. (1600-1970)*365 - (1972-1600)/4 + 3 + 366)
  488. assert_equal(np.array('1900', dtype='M8[D]').astype('i8'),
  489. (1900-1970)*365 - (1970-1900)//4)
  490. assert_equal(np.array('1901', dtype='M8[D]').astype('i8'),
  491. (1900-1970)*365 - (1970-1900)//4 + 365)
  492. assert_equal(np.array('1967', dtype='M8[D]').astype('i8'), -3*365 - 1)
  493. assert_equal(np.array('1968', dtype='M8[D]').astype('i8'), -2*365 - 1)
  494. assert_equal(np.array('1969', dtype='M8[D]').astype('i8'), -1*365)
  495. assert_equal(np.array('1970', dtype='M8[D]').astype('i8'), 0*365)
  496. assert_equal(np.array('1971', dtype='M8[D]').astype('i8'), 1*365)
  497. assert_equal(np.array('1972', dtype='M8[D]').astype('i8'), 2*365)
  498. assert_equal(np.array('1973', dtype='M8[D]').astype('i8'), 3*365 + 1)
  499. assert_equal(np.array('1974', dtype='M8[D]').astype('i8'), 4*365 + 1)
  500. assert_equal(np.array('2000', dtype='M8[D]').astype('i8'),
  501. (2000 - 1970)*365 + (2000 - 1972)//4)
  502. assert_equal(np.array('2001', dtype='M8[D]').astype('i8'),
  503. (2000 - 1970)*365 + (2000 - 1972)//4 + 366)
  504. assert_equal(np.array('2400', dtype='M8[D]').astype('i8'),
  505. (2400 - 1970)*365 + (2400 - 1972)//4 - 3)
  506. assert_equal(np.array('2401', dtype='M8[D]').astype('i8'),
  507. (2400 - 1970)*365 + (2400 - 1972)//4 - 3 + 366)
  508. assert_equal(np.array('1600-02-29', dtype='M8[D]').astype('i8'),
  509. (1600-1970)*365 - (1972-1600)//4 + 3 + 31 + 28)
  510. assert_equal(np.array('1600-03-01', dtype='M8[D]').astype('i8'),
  511. (1600-1970)*365 - (1972-1600)//4 + 3 + 31 + 29)
  512. assert_equal(np.array('2000-02-29', dtype='M8[D]').astype('i8'),
  513. (2000 - 1970)*365 + (2000 - 1972)//4 + 31 + 28)
  514. assert_equal(np.array('2000-03-01', dtype='M8[D]').astype('i8'),
  515. (2000 - 1970)*365 + (2000 - 1972)//4 + 31 + 29)
  516. assert_equal(np.array('2001-03-22', dtype='M8[D]').astype('i8'),
  517. (2000 - 1970)*365 + (2000 - 1972)//4 + 366 + 31 + 28 + 21)
  518. def test_days_to_pydate(self):
  519. assert_equal(np.array('1599', dtype='M8[D]').astype('O'),
  520. datetime.date(1599, 1, 1))
  521. assert_equal(np.array('1600', dtype='M8[D]').astype('O'),
  522. datetime.date(1600, 1, 1))
  523. assert_equal(np.array('1601', dtype='M8[D]').astype('O'),
  524. datetime.date(1601, 1, 1))
  525. assert_equal(np.array('1900', dtype='M8[D]').astype('O'),
  526. datetime.date(1900, 1, 1))
  527. assert_equal(np.array('1901', dtype='M8[D]').astype('O'),
  528. datetime.date(1901, 1, 1))
  529. assert_equal(np.array('2000', dtype='M8[D]').astype('O'),
  530. datetime.date(2000, 1, 1))
  531. assert_equal(np.array('2001', dtype='M8[D]').astype('O'),
  532. datetime.date(2001, 1, 1))
  533. assert_equal(np.array('1600-02-29', dtype='M8[D]').astype('O'),
  534. datetime.date(1600, 2, 29))
  535. assert_equal(np.array('1600-03-01', dtype='M8[D]').astype('O'),
  536. datetime.date(1600, 3, 1))
  537. assert_equal(np.array('2001-03-22', dtype='M8[D]').astype('O'),
  538. datetime.date(2001, 3, 22))
  539. def test_dtype_comparison(self):
  540. assert_(not (np.dtype('M8[us]') == np.dtype('M8[ms]')))
  541. assert_(np.dtype('M8[us]') != np.dtype('M8[ms]'))
  542. assert_(np.dtype('M8[2D]') != np.dtype('M8[D]'))
  543. assert_(np.dtype('M8[D]') != np.dtype('M8[2D]'))
  544. def test_pydatetime_creation(self):
  545. a = np.array(['1960-03-12', datetime.date(1960, 3, 12)], dtype='M8[D]')
  546. assert_equal(a[0], a[1])
  547. a = np.array(['1999-12-31', datetime.date(1999, 12, 31)], dtype='M8[D]')
  548. assert_equal(a[0], a[1])
  549. a = np.array(['2000-01-01', datetime.date(2000, 1, 1)], dtype='M8[D]')
  550. assert_equal(a[0], a[1])
  551. # Will fail if the date changes during the exact right moment
  552. a = np.array(['today', datetime.date.today()], dtype='M8[D]')
  553. assert_equal(a[0], a[1])
  554. # datetime.datetime.now() returns local time, not UTC
  555. #a = np.array(['now', datetime.datetime.now()], dtype='M8[s]')
  556. #assert_equal(a[0], a[1])
  557. # we can give a datetime.date time units
  558. assert_equal(np.array(datetime.date(1960, 3, 12), dtype='M8[s]'),
  559. np.array(np.datetime64('1960-03-12T00:00:00')))
  560. def test_datetime_string_conversion(self):
  561. a = ['2011-03-16', '1920-01-01', '2013-05-19']
  562. str_a = np.array(a, dtype='S')
  563. uni_a = np.array(a, dtype='U')
  564. dt_a = np.array(a, dtype='M')
  565. # String to datetime
  566. assert_equal(dt_a, str_a.astype('M'))
  567. assert_equal(dt_a.dtype, str_a.astype('M').dtype)
  568. dt_b = np.empty_like(dt_a)
  569. dt_b[...] = str_a
  570. assert_equal(dt_a, dt_b)
  571. # Datetime to string
  572. assert_equal(str_a, dt_a.astype('S0'))
  573. str_b = np.empty_like(str_a)
  574. str_b[...] = dt_a
  575. assert_equal(str_a, str_b)
  576. # Unicode to datetime
  577. assert_equal(dt_a, uni_a.astype('M'))
  578. assert_equal(dt_a.dtype, uni_a.astype('M').dtype)
  579. dt_b = np.empty_like(dt_a)
  580. dt_b[...] = uni_a
  581. assert_equal(dt_a, dt_b)
  582. # Datetime to unicode
  583. assert_equal(uni_a, dt_a.astype('U'))
  584. uni_b = np.empty_like(uni_a)
  585. uni_b[...] = dt_a
  586. assert_equal(uni_a, uni_b)
  587. # Datetime to long string - gh-9712
  588. assert_equal(str_a, dt_a.astype((np.string_, 128)))
  589. str_b = np.empty(str_a.shape, dtype=(np.string_, 128))
  590. str_b[...] = dt_a
  591. assert_equal(str_a, str_b)
  592. def test_datetime_array_str(self):
  593. a = np.array(['2011-03-16', '1920-01-01', '2013-05-19'], dtype='M')
  594. assert_equal(str(a), "['2011-03-16' '1920-01-01' '2013-05-19']")
  595. a = np.array(['2011-03-16T13:55', '1920-01-01T03:12'], dtype='M')
  596. assert_equal(np.array2string(a, separator=', ',
  597. formatter={'datetime': lambda x:
  598. "'%s'" % np.datetime_as_string(x, timezone='UTC')}),
  599. "['2011-03-16T13:55Z', '1920-01-01T03:12Z']")
  600. # Check that one NaT doesn't corrupt subsequent entries
  601. a = np.array(['2010', 'NaT', '2030']).astype('M')
  602. assert_equal(str(a), "['2010' 'NaT' '2030']")
  603. def test_timedelta_array_str(self):
  604. a = np.array([-1, 0, 100], dtype='m')
  605. assert_equal(str(a), "[ -1 0 100]")
  606. a = np.array(['NaT', 'NaT'], dtype='m')
  607. assert_equal(str(a), "['NaT' 'NaT']")
  608. # Check right-alignment with NaTs
  609. a = np.array([-1, 'NaT', 0], dtype='m')
  610. assert_equal(str(a), "[ -1 'NaT' 0]")
  611. a = np.array([-1, 'NaT', 1234567], dtype='m')
  612. assert_equal(str(a), "[ -1 'NaT' 1234567]")
  613. # Test with other byteorder:
  614. a = np.array([-1, 'NaT', 1234567], dtype='>m')
  615. assert_equal(str(a), "[ -1 'NaT' 1234567]")
  616. a = np.array([-1, 'NaT', 1234567], dtype='<m')
  617. assert_equal(str(a), "[ -1 'NaT' 1234567]")
  618. def test_pickle(self):
  619. # Check that pickle roundtripping works
  620. for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
  621. dt = np.dtype('M8[7D]')
  622. assert_equal(pickle.loads(pickle.dumps(dt, protocol=proto)), dt)
  623. dt = np.dtype('M8[W]')
  624. assert_equal(pickle.loads(pickle.dumps(dt, protocol=proto)), dt)
  625. scalar = np.datetime64('2016-01-01T00:00:00.000000000')
  626. assert_equal(pickle.loads(pickle.dumps(scalar, protocol=proto)),
  627. scalar)
  628. delta = scalar - np.datetime64('2015-01-01T00:00:00.000000000')
  629. assert_equal(pickle.loads(pickle.dumps(delta, protocol=proto)),
  630. delta)
  631. # Check that loading pickles from 1.6 works
  632. pkl = b"cnumpy\ndtype\np0\n(S'M8'\np1\nI0\nI1\ntp2\nRp3\n" + \
  633. b"(I4\nS'<'\np4\nNNNI-1\nI-1\nI0\n((dp5\n(S'D'\np6\n" + \
  634. b"I7\nI1\nI1\ntp7\ntp8\ntp9\nb."
  635. assert_equal(pickle.loads(pkl), np.dtype('<M8[7D]'))
  636. pkl = b"cnumpy\ndtype\np0\n(S'M8'\np1\nI0\nI1\ntp2\nRp3\n" + \
  637. b"(I4\nS'<'\np4\nNNNI-1\nI-1\nI0\n((dp5\n(S'W'\np6\n" + \
  638. b"I1\nI1\nI1\ntp7\ntp8\ntp9\nb."
  639. assert_equal(pickle.loads(pkl), np.dtype('<M8[W]'))
  640. pkl = b"cnumpy\ndtype\np0\n(S'M8'\np1\nI0\nI1\ntp2\nRp3\n" + \
  641. b"(I4\nS'>'\np4\nNNNI-1\nI-1\nI0\n((dp5\n(S'us'\np6\n" + \
  642. b"I1\nI1\nI1\ntp7\ntp8\ntp9\nb."
  643. assert_equal(pickle.loads(pkl), np.dtype('>M8[us]'))
  644. def test_setstate(self):
  645. "Verify that datetime dtype __setstate__ can handle bad arguments"
  646. dt = np.dtype('>M8[us]')
  647. assert_raises(ValueError, dt.__setstate__, (4, '>', None, None, None, -1, -1, 0, 1))
  648. assert_(dt.__reduce__()[2] == np.dtype('>M8[us]').__reduce__()[2])
  649. assert_raises(TypeError, dt.__setstate__, (4, '>', None, None, None, -1, -1, 0, ({}, 'xxx')))
  650. assert_(dt.__reduce__()[2] == np.dtype('>M8[us]').__reduce__()[2])
  651. def test_dtype_promotion(self):
  652. # datetime <op> datetime computes the metadata gcd
  653. # timedelta <op> timedelta computes the metadata gcd
  654. for mM in ['m', 'M']:
  655. assert_equal(
  656. np.promote_types(np.dtype(mM+'8[2Y]'), np.dtype(mM+'8[2Y]')),
  657. np.dtype(mM+'8[2Y]'))
  658. assert_equal(
  659. np.promote_types(np.dtype(mM+'8[12Y]'), np.dtype(mM+'8[15Y]')),
  660. np.dtype(mM+'8[3Y]'))
  661. assert_equal(
  662. np.promote_types(np.dtype(mM+'8[62M]'), np.dtype(mM+'8[24M]')),
  663. np.dtype(mM+'8[2M]'))
  664. assert_equal(
  665. np.promote_types(np.dtype(mM+'8[1W]'), np.dtype(mM+'8[2D]')),
  666. np.dtype(mM+'8[1D]'))
  667. assert_equal(
  668. np.promote_types(np.dtype(mM+'8[W]'), np.dtype(mM+'8[13s]')),
  669. np.dtype(mM+'8[s]'))
  670. assert_equal(
  671. np.promote_types(np.dtype(mM+'8[13W]'), np.dtype(mM+'8[49s]')),
  672. np.dtype(mM+'8[7s]'))
  673. # timedelta <op> timedelta raises when there is no reasonable gcd
  674. assert_raises(TypeError, np.promote_types,
  675. np.dtype('m8[Y]'), np.dtype('m8[D]'))
  676. assert_raises(TypeError, np.promote_types,
  677. np.dtype('m8[M]'), np.dtype('m8[W]'))
  678. # timedelta and float cannot be safely cast with each other
  679. assert_raises(TypeError, np.promote_types, "float32", "m8")
  680. assert_raises(TypeError, np.promote_types, "m8", "float32")
  681. assert_raises(TypeError, np.promote_types, "uint64", "m8")
  682. assert_raises(TypeError, np.promote_types, "m8", "uint64")
  683. # timedelta <op> timedelta may overflow with big unit ranges
  684. assert_raises(OverflowError, np.promote_types,
  685. np.dtype('m8[W]'), np.dtype('m8[fs]'))
  686. assert_raises(OverflowError, np.promote_types,
  687. np.dtype('m8[s]'), np.dtype('m8[as]'))
  688. def test_cast_overflow(self):
  689. # gh-4486
  690. def cast():
  691. numpy.datetime64("1971-01-01 00:00:00.000000000000000").astype("<M8[D]")
  692. assert_raises(OverflowError, cast)
  693. def cast2():
  694. numpy.datetime64("2014").astype("<M8[fs]")
  695. assert_raises(OverflowError, cast2)
  696. def test_pyobject_roundtrip(self):
  697. # All datetime types should be able to roundtrip through object
  698. a = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0,
  699. -1020040340, -2942398, -1, 0, 1, 234523453, 1199164176],
  700. dtype=np.int64)
  701. # With date units
  702. for unit in ['M8[D]', 'M8[W]', 'M8[M]', 'M8[Y]']:
  703. b = a.copy().view(dtype=unit)
  704. b[0] = '-0001-01-01'
  705. b[1] = '-0001-12-31'
  706. b[2] = '0000-01-01'
  707. b[3] = '0001-01-01'
  708. b[4] = '1969-12-31'
  709. b[5] = '1970-01-01'
  710. b[6] = '9999-12-31'
  711. b[7] = '10000-01-01'
  712. b[8] = 'NaT'
  713. assert_equal(b.astype(object).astype(unit), b,
  714. "Error roundtripping unit %s" % unit)
  715. # With time units
  716. for unit in ['M8[as]', 'M8[16fs]', 'M8[ps]', 'M8[us]',
  717. 'M8[300as]', 'M8[20us]']:
  718. b = a.copy().view(dtype=unit)
  719. b[0] = '-0001-01-01T00'
  720. b[1] = '-0001-12-31T00'
  721. b[2] = '0000-01-01T00'
  722. b[3] = '0001-01-01T00'
  723. b[4] = '1969-12-31T23:59:59.999999'
  724. b[5] = '1970-01-01T00'
  725. b[6] = '9999-12-31T23:59:59.999999'
  726. b[7] = '10000-01-01T00'
  727. b[8] = 'NaT'
  728. assert_equal(b.astype(object).astype(unit), b,
  729. "Error roundtripping unit %s" % unit)
  730. def test_month_truncation(self):
  731. # Make sure that months are truncating correctly
  732. assert_equal(np.array('1945-03-01', dtype='M8[M]'),
  733. np.array('1945-03-31', dtype='M8[M]'))
  734. assert_equal(np.array('1969-11-01', dtype='M8[M]'),
  735. np.array('1969-11-30T23:59:59.99999', dtype='M').astype('M8[M]'))
  736. assert_equal(np.array('1969-12-01', dtype='M8[M]'),
  737. np.array('1969-12-31T23:59:59.99999', dtype='M').astype('M8[M]'))
  738. assert_equal(np.array('1970-01-01', dtype='M8[M]'),
  739. np.array('1970-01-31T23:59:59.99999', dtype='M').astype('M8[M]'))
  740. assert_equal(np.array('1980-02-01', dtype='M8[M]'),
  741. np.array('1980-02-29T23:59:59.99999', dtype='M').astype('M8[M]'))
  742. def test_different_unit_comparison(self):
  743. # Check some years with date units
  744. for unit1 in ['Y', 'M', 'D']:
  745. dt1 = np.dtype('M8[%s]' % unit1)
  746. for unit2 in ['Y', 'M', 'D']:
  747. dt2 = np.dtype('M8[%s]' % unit2)
  748. assert_equal(np.array('1945', dtype=dt1),
  749. np.array('1945', dtype=dt2))
  750. assert_equal(np.array('1970', dtype=dt1),
  751. np.array('1970', dtype=dt2))
  752. assert_equal(np.array('9999', dtype=dt1),
  753. np.array('9999', dtype=dt2))
  754. assert_equal(np.array('10000', dtype=dt1),
  755. np.array('10000-01-01', dtype=dt2))
  756. assert_equal(np.datetime64('1945', unit1),
  757. np.datetime64('1945', unit2))
  758. assert_equal(np.datetime64('1970', unit1),
  759. np.datetime64('1970', unit2))
  760. assert_equal(np.datetime64('9999', unit1),
  761. np.datetime64('9999', unit2))
  762. assert_equal(np.datetime64('10000', unit1),
  763. np.datetime64('10000-01-01', unit2))
  764. # Check some datetimes with time units
  765. for unit1 in ['6h', 'h', 'm', 's', '10ms', 'ms', 'us']:
  766. dt1 = np.dtype('M8[%s]' % unit1)
  767. for unit2 in ['h', 'm', 's', 'ms', 'us']:
  768. dt2 = np.dtype('M8[%s]' % unit2)
  769. assert_equal(np.array('1945-03-12T18', dtype=dt1),
  770. np.array('1945-03-12T18', dtype=dt2))
  771. assert_equal(np.array('1970-03-12T18', dtype=dt1),
  772. np.array('1970-03-12T18', dtype=dt2))
  773. assert_equal(np.array('9999-03-12T18', dtype=dt1),
  774. np.array('9999-03-12T18', dtype=dt2))
  775. assert_equal(np.array('10000-01-01T00', dtype=dt1),
  776. np.array('10000-01-01T00', dtype=dt2))
  777. assert_equal(np.datetime64('1945-03-12T18', unit1),
  778. np.datetime64('1945-03-12T18', unit2))
  779. assert_equal(np.datetime64('1970-03-12T18', unit1),
  780. np.datetime64('1970-03-12T18', unit2))
  781. assert_equal(np.datetime64('9999-03-12T18', unit1),
  782. np.datetime64('9999-03-12T18', unit2))
  783. assert_equal(np.datetime64('10000-01-01T00', unit1),
  784. np.datetime64('10000-01-01T00', unit2))
  785. # Check some days with units that won't overflow
  786. for unit1 in ['D', '12h', 'h', 'm', 's', '4s', 'ms', 'us']:
  787. dt1 = np.dtype('M8[%s]' % unit1)
  788. for unit2 in ['D', 'h', 'm', 's', 'ms', 'us']:
  789. dt2 = np.dtype('M8[%s]' % unit2)
  790. assert_(np.equal(np.array('1932-02-17', dtype='M').astype(dt1),
  791. np.array('1932-02-17T00:00:00', dtype='M').astype(dt2),
  792. casting='unsafe'))
  793. assert_(np.equal(np.array('10000-04-27', dtype='M').astype(dt1),
  794. np.array('10000-04-27T00:00:00', dtype='M').astype(dt2),
  795. casting='unsafe'))
  796. # Shouldn't be able to compare datetime and timedelta
  797. # TODO: Changing to 'same_kind' or 'safe' casting in the ufuncs by
  798. # default is needed to properly catch this kind of thing...
  799. a = np.array('2012-12-21', dtype='M8[D]')
  800. b = np.array(3, dtype='m8[D]')
  801. #assert_raises(TypeError, np.less, a, b)
  802. assert_raises(TypeError, np.less, a, b, casting='same_kind')
  803. def test_datetime_like(self):
  804. a = np.array([3], dtype='m8[4D]')
  805. b = np.array(['2012-12-21'], dtype='M8[D]')
  806. assert_equal(np.ones_like(a).dtype, a.dtype)
  807. assert_equal(np.zeros_like(a).dtype, a.dtype)
  808. assert_equal(np.empty_like(a).dtype, a.dtype)
  809. assert_equal(np.ones_like(b).dtype, b.dtype)
  810. assert_equal(np.zeros_like(b).dtype, b.dtype)
  811. assert_equal(np.empty_like(b).dtype, b.dtype)
  812. def test_datetime_unary(self):
  813. for tda, tdb, tdzero, tdone, tdmone in \
  814. [
  815. # One-dimensional arrays
  816. (np.array([3], dtype='m8[D]'),
  817. np.array([-3], dtype='m8[D]'),
  818. np.array([0], dtype='m8[D]'),
  819. np.array([1], dtype='m8[D]'),
  820. np.array([-1], dtype='m8[D]')),
  821. # NumPy scalars
  822. (np.timedelta64(3, '[D]'),
  823. np.timedelta64(-3, '[D]'),
  824. np.timedelta64(0, '[D]'),
  825. np.timedelta64(1, '[D]'),
  826. np.timedelta64(-1, '[D]'))]:
  827. # negative ufunc
  828. assert_equal(-tdb, tda)
  829. assert_equal((-tdb).dtype, tda.dtype)
  830. assert_equal(np.negative(tdb), tda)
  831. assert_equal(np.negative(tdb).dtype, tda.dtype)
  832. # positive ufunc
  833. assert_equal(np.positive(tda), tda)
  834. assert_equal(np.positive(tda).dtype, tda.dtype)
  835. assert_equal(np.positive(tdb), tdb)
  836. assert_equal(np.positive(tdb).dtype, tdb.dtype)
  837. # absolute ufunc
  838. assert_equal(np.absolute(tdb), tda)
  839. assert_equal(np.absolute(tdb).dtype, tda.dtype)
  840. # sign ufunc
  841. assert_equal(np.sign(tda), tdone)
  842. assert_equal(np.sign(tdb), tdmone)
  843. assert_equal(np.sign(tdzero), tdzero)
  844. assert_equal(np.sign(tda).dtype, tda.dtype)
  845. # The ufuncs always produce native-endian results
  846. assert_
  847. def test_datetime_add(self):
  848. for dta, dtb, dtc, dtnat, tda, tdb, tdc in \
  849. [
  850. # One-dimensional arrays
  851. (np.array(['2012-12-21'], dtype='M8[D]'),
  852. np.array(['2012-12-24'], dtype='M8[D]'),
  853. np.array(['2012-12-21T11'], dtype='M8[h]'),
  854. np.array(['NaT'], dtype='M8[D]'),
  855. np.array([3], dtype='m8[D]'),
  856. np.array([11], dtype='m8[h]'),
  857. np.array([3*24 + 11], dtype='m8[h]')),
  858. # NumPy scalars
  859. (np.datetime64('2012-12-21', '[D]'),
  860. np.datetime64('2012-12-24', '[D]'),
  861. np.datetime64('2012-12-21T11', '[h]'),
  862. np.datetime64('NaT', '[D]'),
  863. np.timedelta64(3, '[D]'),
  864. np.timedelta64(11, '[h]'),
  865. np.timedelta64(3*24 + 11, '[h]'))]:
  866. # m8 + m8
  867. assert_equal(tda + tdb, tdc)
  868. assert_equal((tda + tdb).dtype, np.dtype('m8[h]'))
  869. # m8 + bool
  870. assert_equal(tdb + True, tdb + 1)
  871. assert_equal((tdb + True).dtype, np.dtype('m8[h]'))
  872. # m8 + int
  873. assert_equal(tdb + 3*24, tdc)
  874. assert_equal((tdb + 3*24).dtype, np.dtype('m8[h]'))
  875. # bool + m8
  876. assert_equal(False + tdb, tdb)
  877. assert_equal((False + tdb).dtype, np.dtype('m8[h]'))
  878. # int + m8
  879. assert_equal(3*24 + tdb, tdc)
  880. assert_equal((3*24 + tdb).dtype, np.dtype('m8[h]'))
  881. # M8 + bool
  882. assert_equal(dta + True, dta + 1)
  883. assert_equal(dtnat + True, dtnat)
  884. assert_equal((dta + True).dtype, np.dtype('M8[D]'))
  885. # M8 + int
  886. assert_equal(dta + 3, dtb)
  887. assert_equal(dtnat + 3, dtnat)
  888. assert_equal((dta + 3).dtype, np.dtype('M8[D]'))
  889. # bool + M8
  890. assert_equal(False + dta, dta)
  891. assert_equal(False + dtnat, dtnat)
  892. assert_equal((False + dta).dtype, np.dtype('M8[D]'))
  893. # int + M8
  894. assert_equal(3 + dta, dtb)
  895. assert_equal(3 + dtnat, dtnat)
  896. assert_equal((3 + dta).dtype, np.dtype('M8[D]'))
  897. # M8 + m8
  898. assert_equal(dta + tda, dtb)
  899. assert_equal(dtnat + tda, dtnat)
  900. assert_equal((dta + tda).dtype, np.dtype('M8[D]'))
  901. # m8 + M8
  902. assert_equal(tda + dta, dtb)
  903. assert_equal(tda + dtnat, dtnat)
  904. assert_equal((tda + dta).dtype, np.dtype('M8[D]'))
  905. # In M8 + m8, the result goes to higher precision
  906. assert_equal(np.add(dta, tdb, casting='unsafe'), dtc)
  907. assert_equal(np.add(dta, tdb, casting='unsafe').dtype,
  908. np.dtype('M8[h]'))
  909. assert_equal(np.add(tdb, dta, casting='unsafe'), dtc)
  910. assert_equal(np.add(tdb, dta, casting='unsafe').dtype,
  911. np.dtype('M8[h]'))
  912. # M8 + M8
  913. assert_raises(TypeError, np.add, dta, dtb)
  914. def test_datetime_subtract(self):
  915. for dta, dtb, dtc, dtd, dte, dtnat, tda, tdb, tdc in \
  916. [
  917. # One-dimensional arrays
  918. (np.array(['2012-12-21'], dtype='M8[D]'),
  919. np.array(['2012-12-24'], dtype='M8[D]'),
  920. np.array(['1940-12-24'], dtype='M8[D]'),
  921. np.array(['1940-12-24T00'], dtype='M8[h]'),
  922. np.array(['1940-12-23T13'], dtype='M8[h]'),
  923. np.array(['NaT'], dtype='M8[D]'),
  924. np.array([3], dtype='m8[D]'),
  925. np.array([11], dtype='m8[h]'),
  926. np.array([3*24 - 11], dtype='m8[h]')),
  927. # NumPy scalars
  928. (np.datetime64('2012-12-21', '[D]'),
  929. np.datetime64('2012-12-24', '[D]'),
  930. np.datetime64('1940-12-24', '[D]'),
  931. np.datetime64('1940-12-24T00', '[h]'),
  932. np.datetime64('1940-12-23T13', '[h]'),
  933. np.datetime64('NaT', '[D]'),
  934. np.timedelta64(3, '[D]'),
  935. np.timedelta64(11, '[h]'),
  936. np.timedelta64(3*24 - 11, '[h]'))]:
  937. # m8 - m8
  938. assert_equal(tda - tdb, tdc)
  939. assert_equal((tda - tdb).dtype, np.dtype('m8[h]'))
  940. assert_equal(tdb - tda, -tdc)
  941. assert_equal((tdb - tda).dtype, np.dtype('m8[h]'))
  942. # m8 - bool
  943. assert_equal(tdc - True, tdc - 1)
  944. assert_equal((tdc - True).dtype, np.dtype('m8[h]'))
  945. # m8 - int
  946. assert_equal(tdc - 3*24, -tdb)
  947. assert_equal((tdc - 3*24).dtype, np.dtype('m8[h]'))
  948. # int - m8
  949. assert_equal(False - tdb, -tdb)
  950. assert_equal((False - tdb).dtype, np.dtype('m8[h]'))
  951. # int - m8
  952. assert_equal(3*24 - tdb, tdc)
  953. assert_equal((3*24 - tdb).dtype, np.dtype('m8[h]'))
  954. # M8 - bool
  955. assert_equal(dtb - True, dtb - 1)
  956. assert_equal(dtnat - True, dtnat)
  957. assert_equal((dtb - True).dtype, np.dtype('M8[D]'))
  958. # M8 - int
  959. assert_equal(dtb - 3, dta)
  960. assert_equal(dtnat - 3, dtnat)
  961. assert_equal((dtb - 3).dtype, np.dtype('M8[D]'))
  962. # M8 - m8
  963. assert_equal(dtb - tda, dta)
  964. assert_equal(dtnat - tda, dtnat)
  965. assert_equal((dtb - tda).dtype, np.dtype('M8[D]'))
  966. # In M8 - m8, the result goes to higher precision
  967. assert_equal(np.subtract(dtc, tdb, casting='unsafe'), dte)
  968. assert_equal(np.subtract(dtc, tdb, casting='unsafe').dtype,
  969. np.dtype('M8[h]'))
  970. # M8 - M8 with different goes to higher precision
  971. assert_equal(np.subtract(dtc, dtd, casting='unsafe'),
  972. np.timedelta64(0, 'h'))
  973. assert_equal(np.subtract(dtc, dtd, casting='unsafe').dtype,
  974. np.dtype('m8[h]'))
  975. assert_equal(np.subtract(dtd, dtc, casting='unsafe'),
  976. np.timedelta64(0, 'h'))
  977. assert_equal(np.subtract(dtd, dtc, casting='unsafe').dtype,
  978. np.dtype('m8[h]'))
  979. # m8 - M8
  980. assert_raises(TypeError, np.subtract, tda, dta)
  981. # bool - M8
  982. assert_raises(TypeError, np.subtract, False, dta)
  983. # int - M8
  984. assert_raises(TypeError, np.subtract, 3, dta)
  985. def test_datetime_multiply(self):
  986. for dta, tda, tdb, tdc in \
  987. [
  988. # One-dimensional arrays
  989. (np.array(['2012-12-21'], dtype='M8[D]'),
  990. np.array([6], dtype='m8[h]'),
  991. np.array([9], dtype='m8[h]'),
  992. np.array([12], dtype='m8[h]')),
  993. # NumPy scalars
  994. (np.datetime64('2012-12-21', '[D]'),
  995. np.timedelta64(6, '[h]'),
  996. np.timedelta64(9, '[h]'),
  997. np.timedelta64(12, '[h]'))]:
  998. # m8 * int
  999. assert_equal(tda * 2, tdc)
  1000. assert_equal((tda * 2).dtype, np.dtype('m8[h]'))
  1001. # int * m8
  1002. assert_equal(2 * tda, tdc)
  1003. assert_equal((2 * tda).dtype, np.dtype('m8[h]'))
  1004. # m8 * float
  1005. assert_equal(tda * 1.5, tdb)
  1006. assert_equal((tda * 1.5).dtype, np.dtype('m8[h]'))
  1007. # float * m8
  1008. assert_equal(1.5 * tda, tdb)
  1009. assert_equal((1.5 * tda).dtype, np.dtype('m8[h]'))
  1010. # m8 * m8
  1011. assert_raises(TypeError, np.multiply, tda, tdb)
  1012. # m8 * M8
  1013. assert_raises(TypeError, np.multiply, dta, tda)
  1014. # M8 * m8
  1015. assert_raises(TypeError, np.multiply, tda, dta)
  1016. # M8 * int
  1017. assert_raises(TypeError, np.multiply, dta, 2)
  1018. # int * M8
  1019. assert_raises(TypeError, np.multiply, 2, dta)
  1020. # M8 * float
  1021. assert_raises(TypeError, np.multiply, dta, 1.5)
  1022. # float * M8
  1023. assert_raises(TypeError, np.multiply, 1.5, dta)
  1024. # NaTs
  1025. with suppress_warnings() as sup:
  1026. sup.filter(RuntimeWarning, "invalid value encountered in multiply")
  1027. nat = np.timedelta64('NaT')
  1028. def check(a, b, res):
  1029. assert_equal(a * b, res)
  1030. assert_equal(b * a, res)
  1031. for tp in (int, float):
  1032. check(nat, tp(2), nat)
  1033. check(nat, tp(0), nat)
  1034. for f in (float('inf'), float('nan')):
  1035. check(np.timedelta64(1), f, nat)
  1036. check(np.timedelta64(0), f, nat)
  1037. check(nat, f, nat)
  1038. @pytest.mark.parametrize("op1, op2, exp", [
  1039. # m8 same units round down
  1040. (np.timedelta64(7, 's'),
  1041. np.timedelta64(4, 's'),
  1042. 1),
  1043. # m8 same units round down with negative
  1044. (np.timedelta64(7, 's'),
  1045. np.timedelta64(-4, 's'),
  1046. -2),
  1047. # m8 same units negative no round down
  1048. (np.timedelta64(8, 's'),
  1049. np.timedelta64(-4, 's'),
  1050. -2),
  1051. # m8 different units
  1052. (np.timedelta64(1, 'm'),
  1053. np.timedelta64(31, 's'),
  1054. 1),
  1055. # m8 generic units
  1056. (np.timedelta64(1890),
  1057. np.timedelta64(31),
  1058. 60),
  1059. # Y // M works
  1060. (np.timedelta64(2, 'Y'),
  1061. np.timedelta64('13', 'M'),
  1062. 1),
  1063. # handle 1D arrays
  1064. (np.array([1, 2, 3], dtype='m8'),
  1065. np.array([2], dtype='m8'),
  1066. np.array([0, 1, 1], dtype=np.int64)),
  1067. ])
  1068. def test_timedelta_floor_divide(self, op1, op2, exp):
  1069. assert_equal(op1 // op2, exp)
  1070. @pytest.mark.parametrize("op1, op2", [
  1071. # div by 0
  1072. (np.timedelta64(10, 'us'),
  1073. np.timedelta64(0, 'us')),
  1074. # div with NaT
  1075. (np.timedelta64('NaT'),
  1076. np.timedelta64(50, 'us')),
  1077. # special case for int64 min
  1078. # in integer floor division
  1079. (np.timedelta64(np.iinfo(np.int64).min),
  1080. np.timedelta64(-1)),
  1081. ])
  1082. def test_timedelta_floor_div_warnings(self, op1, op2):
  1083. with assert_warns(RuntimeWarning):
  1084. actual = op1 // op2
  1085. assert_equal(actual, 0)
  1086. assert_equal(actual.dtype, np.int64)
  1087. @pytest.mark.parametrize("val1, val2", [
  1088. # the smallest integer that can't be represented
  1089. # exactly in a double should be preserved if we avoid
  1090. # casting to double in floordiv operation
  1091. (9007199254740993, 1),
  1092. # stress the alternate floordiv code path where
  1093. # operand signs don't match and remainder isn't 0
  1094. (9007199254740999, -2),
  1095. ])
  1096. def test_timedelta_floor_div_precision(self, val1, val2):
  1097. op1 = np.timedelta64(val1)
  1098. op2 = np.timedelta64(val2)
  1099. actual = op1 // op2
  1100. # Python reference integer floor
  1101. expected = val1 // val2
  1102. assert_equal(actual, expected)
  1103. @pytest.mark.parametrize("val1, val2", [
  1104. # years and months sometimes can't be unambiguously
  1105. # divided for floor division operation
  1106. (np.timedelta64(7, 'Y'),
  1107. np.timedelta64(3, 's')),
  1108. (np.timedelta64(7, 'M'),
  1109. np.timedelta64(1, 'D')),
  1110. ])
  1111. def test_timedelta_floor_div_error(self, val1, val2):
  1112. with assert_raises_regex(TypeError, "common metadata divisor"):
  1113. val1 // val2
  1114. @pytest.mark.parametrize("op1, op2", [
  1115. # reuse the test cases from floordiv
  1116. (np.timedelta64(7, 's'),
  1117. np.timedelta64(4, 's')),
  1118. # m8 same units round down with negative
  1119. (np.timedelta64(7, 's'),
  1120. np.timedelta64(-4, 's')),
  1121. # m8 same units negative no round down
  1122. (np.timedelta64(8, 's'),
  1123. np.timedelta64(-4, 's')),
  1124. # m8 different units
  1125. (np.timedelta64(1, 'm'),
  1126. np.timedelta64(31, 's')),
  1127. # m8 generic units
  1128. (np.timedelta64(1890),
  1129. np.timedelta64(31)),
  1130. # Y // M works
  1131. (np.timedelta64(2, 'Y'),
  1132. np.timedelta64('13', 'M')),
  1133. # handle 1D arrays
  1134. (np.array([1, 2, 3], dtype='m8'),
  1135. np.array([2], dtype='m8')),
  1136. ])
  1137. def test_timedelta_divmod(self, op1, op2):
  1138. expected = (op1 // op2, op1 % op2)
  1139. assert_equal(divmod(op1, op2), expected)
  1140. @pytest.mark.parametrize("op1, op2", [
  1141. # reuse cases from floordiv
  1142. # div by 0
  1143. (np.timedelta64(10, 'us'),
  1144. np.timedelta64(0, 'us')),
  1145. # div with NaT
  1146. (np.timedelta64('NaT'),
  1147. np.timedelta64(50, 'us')),
  1148. # special case for int64 min
  1149. # in integer floor division
  1150. (np.timedelta64(np.iinfo(np.int64).min),
  1151. np.timedelta64(-1)),
  1152. ])
  1153. def test_timedelta_divmod_warnings(self, op1, op2):
  1154. with assert_warns(RuntimeWarning):
  1155. expected = (op1 // op2, op1 % op2)
  1156. with assert_warns(RuntimeWarning):
  1157. actual = divmod(op1, op2)
  1158. assert_equal(actual, expected)
  1159. def test_datetime_divide(self):
  1160. for dta, tda, tdb, tdc, tdd in \
  1161. [
  1162. # One-dimensional arrays
  1163. (np.array(['2012-12-21'], dtype='M8[D]'),
  1164. np.array([6], dtype='m8[h]'),
  1165. np.array([9], dtype='m8[h]'),
  1166. np.array([12], dtype='m8[h]'),
  1167. np.array([6], dtype='m8[m]')),
  1168. # NumPy scalars
  1169. (np.datetime64('2012-12-21', '[D]'),
  1170. np.timedelta64(6, '[h]'),
  1171. np.timedelta64(9, '[h]'),
  1172. np.timedelta64(12, '[h]'),
  1173. np.timedelta64(6, '[m]'))]:
  1174. # m8 / int
  1175. assert_equal(tdc / 2, tda)
  1176. assert_equal((tdc / 2).dtype, np.dtype('m8[h]'))
  1177. # m8 / float
  1178. assert_equal(tda / 0.5, tdc)
  1179. assert_equal((tda / 0.5).dtype, np.dtype('m8[h]'))
  1180. # m8 / m8
  1181. assert_equal(tda / tdb, 6.0 / 9.0)
  1182. assert_equal(np.divide(tda, tdb), 6.0 / 9.0)
  1183. assert_equal(np.true_divide(tda, tdb), 6.0 / 9.0)
  1184. assert_equal(tdb / tda, 9.0 / 6.0)
  1185. assert_equal((tda / tdb).dtype, np.dtype('f8'))
  1186. assert_equal(tda / tdd, 60.0)
  1187. assert_equal(tdd / tda, 1.0 / 60.0)
  1188. # int / m8
  1189. assert_raises(TypeError, np.divide, 2, tdb)
  1190. # float / m8
  1191. assert_raises(TypeError, np.divide, 0.5, tdb)
  1192. # m8 / M8
  1193. assert_raises(TypeError, np.divide, dta, tda)
  1194. # M8 / m8
  1195. assert_raises(TypeError, np.divide, tda, dta)
  1196. # M8 / int
  1197. assert_raises(TypeError, np.divide, dta, 2)
  1198. # int / M8
  1199. assert_raises(TypeError, np.divide, 2, dta)
  1200. # M8 / float
  1201. assert_raises(TypeError, np.divide, dta, 1.5)
  1202. # float / M8
  1203. assert_raises(TypeError, np.divide, 1.5, dta)
  1204. # NaTs
  1205. with suppress_warnings() as sup:
  1206. sup.filter(RuntimeWarning, r".*encountered in true\_divide")
  1207. nat = np.timedelta64('NaT')
  1208. for tp in (int, float):
  1209. assert_equal(np.timedelta64(1) / tp(0), nat)
  1210. assert_equal(np.timedelta64(0) / tp(0), nat)
  1211. assert_equal(nat / tp(0), nat)
  1212. assert_equal(nat / tp(2), nat)
  1213. # Division by inf
  1214. assert_equal(np.timedelta64(1) / float('inf'), np.timedelta64(0))
  1215. assert_equal(np.timedelta64(0) / float('inf'), np.timedelta64(0))
  1216. assert_equal(nat / float('inf'), nat)
  1217. # Division by nan
  1218. assert_equal(np.timedelta64(1) / float('nan'), nat)
  1219. assert_equal(np.timedelta64(0) / float('nan'), nat)
  1220. assert_equal(nat / float('nan'), nat)
  1221. def test_datetime_compare(self):
  1222. # Test all the comparison operators
  1223. a = np.datetime64('2000-03-12T18:00:00.000000')
  1224. b = np.array(['2000-03-12T18:00:00.000000',
  1225. '2000-03-12T17:59:59.999999',
  1226. '2000-03-12T18:00:00.000001',
  1227. '1970-01-11T12:00:00.909090',
  1228. '2016-01-11T12:00:00.909090'],
  1229. dtype='datetime64[us]')
  1230. assert_equal(np.equal(a, b), [1, 0, 0, 0, 0])
  1231. assert_equal(np.not_equal(a, b), [0, 1, 1, 1, 1])
  1232. assert_equal(np.less(a, b), [0, 0, 1, 0, 1])
  1233. assert_equal(np.less_equal(a, b), [1, 0, 1, 0, 1])
  1234. assert_equal(np.greater(a, b), [0, 1, 0, 1, 0])
  1235. assert_equal(np.greater_equal(a, b), [1, 1, 0, 1, 0])
  1236. def test_datetime_compare_nat(self):
  1237. dt_nat = np.datetime64('NaT', 'D')
  1238. dt_other = np.datetime64('2000-01-01')
  1239. td_nat = np.timedelta64('NaT', 'h')
  1240. td_other = np.timedelta64(1, 'h')
  1241. for op in [np.equal, np.less, np.less_equal,
  1242. np.greater, np.greater_equal]:
  1243. assert_(not op(dt_nat, dt_nat))
  1244. assert_(not op(dt_nat, dt_other))
  1245. assert_(not op(dt_other, dt_nat))
  1246. assert_(not op(td_nat, td_nat))
  1247. assert_(not op(td_nat, td_other))
  1248. assert_(not op(td_other, td_nat))
  1249. assert_(np.not_equal(dt_nat, dt_nat))
  1250. assert_(np.not_equal(dt_nat, dt_other))
  1251. assert_(np.not_equal(dt_other, dt_nat))
  1252. assert_(np.not_equal(td_nat, td_nat))
  1253. assert_(np.not_equal(td_nat, td_other))
  1254. assert_(np.not_equal(td_other, td_nat))
  1255. def test_datetime_minmax(self):
  1256. # The metadata of the result should become the GCD
  1257. # of the operand metadata
  1258. a = np.array('1999-03-12T13', dtype='M8[2m]')
  1259. b = np.array('1999-03-12T12', dtype='M8[s]')
  1260. assert_equal(np.minimum(a, b), b)
  1261. assert_equal(np.minimum(a, b).dtype, np.dtype('M8[s]'))
  1262. assert_equal(np.fmin(a, b), b)
  1263. assert_equal(np.fmin(a, b).dtype, np.dtype('M8[s]'))
  1264. assert_equal(np.maximum(a, b), a)
  1265. assert_equal(np.maximum(a, b).dtype, np.dtype('M8[s]'))
  1266. assert_equal(np.fmax(a, b), a)
  1267. assert_equal(np.fmax(a, b).dtype, np.dtype('M8[s]'))
  1268. # Viewed as integers, the comparison is opposite because
  1269. # of the units chosen
  1270. assert_equal(np.minimum(a.view('i8'), b.view('i8')), a.view('i8'))
  1271. # Interaction with NaT
  1272. a = np.array('1999-03-12T13', dtype='M8[2m]')
  1273. dtnat = np.array('NaT', dtype='M8[h]')
  1274. assert_equal(np.minimum(a, dtnat), dtnat)
  1275. assert_equal(np.minimum(dtnat, a), dtnat)
  1276. assert_equal(np.maximum(a, dtnat), dtnat)
  1277. assert_equal(np.maximum(dtnat, a), dtnat)
  1278. assert_equal(np.fmin(dtnat, a), a)
  1279. assert_equal(np.fmin(a, dtnat), a)
  1280. assert_equal(np.fmax(dtnat, a), a)
  1281. assert_equal(np.fmax(a, dtnat), a)
  1282. # Also do timedelta
  1283. a = np.array(3, dtype='m8[h]')
  1284. b = np.array(3*3600 - 3, dtype='m8[s]')
  1285. assert_equal(np.minimum(a, b), b)
  1286. assert_equal(np.minimum(a, b).dtype, np.dtype('m8[s]'))
  1287. assert_equal(np.fmin(a, b), b)
  1288. assert_equal(np.fmin(a, b).dtype, np.dtype('m8[s]'))
  1289. assert_equal(np.maximum(a, b), a)
  1290. assert_equal(np.maximum(a, b).dtype, np.dtype('m8[s]'))
  1291. assert_equal(np.fmax(a, b), a)
  1292. assert_equal(np.fmax(a, b).dtype, np.dtype('m8[s]'))
  1293. # Viewed as integers, the comparison is opposite because
  1294. # of the units chosen
  1295. assert_equal(np.minimum(a.view('i8'), b.view('i8')), a.view('i8'))
  1296. # should raise between datetime and timedelta
  1297. #
  1298. # TODO: Allowing unsafe casting by
  1299. # default in ufuncs strikes again... :(
  1300. a = np.array(3, dtype='m8[h]')
  1301. b = np.array('1999-03-12T12', dtype='M8[s]')
  1302. #assert_raises(TypeError, np.minimum, a, b)
  1303. #assert_raises(TypeError, np.maximum, a, b)
  1304. #assert_raises(TypeError, np.fmin, a, b)
  1305. #assert_raises(TypeError, np.fmax, a, b)
  1306. assert_raises(TypeError, np.minimum, a, b, casting='same_kind')
  1307. assert_raises(TypeError, np.maximum, a, b, casting='same_kind')
  1308. assert_raises(TypeError, np.fmin, a, b, casting='same_kind')
  1309. assert_raises(TypeError, np.fmax, a, b, casting='same_kind')
  1310. def test_hours(self):
  1311. t = np.ones(3, dtype='M8[s]')
  1312. t[0] = 60*60*24 + 60*60*10
  1313. assert_(t[0].item().hour == 10)
  1314. def test_divisor_conversion_year(self):
  1315. assert_(np.dtype('M8[Y/4]') == np.dtype('M8[3M]'))
  1316. assert_(np.dtype('M8[Y/13]') == np.dtype('M8[4W]'))
  1317. assert_(np.dtype('M8[3Y/73]') == np.dtype('M8[15D]'))
  1318. def test_divisor_conversion_month(self):
  1319. assert_(np.dtype('M8[M/2]') == np.dtype('M8[2W]'))
  1320. assert_(np.dtype('M8[M/15]') == np.dtype('M8[2D]'))
  1321. assert_(np.dtype('M8[3M/40]') == np.dtype('M8[54h]'))
  1322. def test_divisor_conversion_week(self):
  1323. assert_(np.dtype('m8[W/7]') == np.dtype('m8[D]'))
  1324. assert_(np.dtype('m8[3W/14]') == np.dtype('m8[36h]'))
  1325. assert_(np.dtype('m8[5W/140]') == np.dtype('m8[360m]'))
  1326. def test_divisor_conversion_day(self):
  1327. assert_(np.dtype('M8[D/12]') == np.dtype('M8[2h]'))
  1328. assert_(np.dtype('M8[D/120]') == np.dtype('M8[12m]'))
  1329. assert_(np.dtype('M8[3D/960]') == np.dtype('M8[270s]'))
  1330. def test_divisor_conversion_hour(self):
  1331. assert_(np.dtype('m8[h/30]') == np.dtype('m8[2m]'))
  1332. assert_(np.dtype('m8[3h/300]') == np.dtype('m8[36s]'))
  1333. def test_divisor_conversion_minute(self):
  1334. assert_(np.dtype('m8[m/30]') == np.dtype('m8[2s]'))
  1335. assert_(np.dtype('m8[3m/300]') == np.dtype('m8[600ms]'))
  1336. def test_divisor_conversion_second(self):
  1337. assert_(np.dtype('m8[s/100]') == np.dtype('m8[10ms]'))
  1338. assert_(np.dtype('m8[3s/10000]') == np.dtype('m8[300us]'))
  1339. def test_divisor_conversion_fs(self):
  1340. assert_(np.dtype('M8[fs/100]') == np.dtype('M8[10as]'))
  1341. assert_raises(ValueError, lambda: np.dtype('M8[3fs/10000]'))
  1342. def test_divisor_conversion_as(self):
  1343. assert_raises(ValueError, lambda: np.dtype('M8[as/10]'))
  1344. def test_string_parser_variants(self):
  1345. # Allow space instead of 'T' between date and time
  1346. assert_equal(np.array(['1980-02-29T01:02:03'], np.dtype('M8[s]')),
  1347. np.array(['1980-02-29 01:02:03'], np.dtype('M8[s]')))
  1348. # Allow positive years
  1349. assert_equal(np.array(['+1980-02-29T01:02:03'], np.dtype('M8[s]')),
  1350. np.array(['+1980-02-29 01:02:03'], np.dtype('M8[s]')))
  1351. # Allow negative years
  1352. assert_equal(np.array(['-1980-02-29T01:02:03'], np.dtype('M8[s]')),
  1353. np.array(['-1980-02-29 01:02:03'], np.dtype('M8[s]')))
  1354. # UTC specifier
  1355. with assert_warns(DeprecationWarning):
  1356. assert_equal(
  1357. np.array(['+1980-02-29T01:02:03'], np.dtype('M8[s]')),
  1358. np.array(['+1980-02-29 01:02:03Z'], np.dtype('M8[s]')))
  1359. with assert_warns(DeprecationWarning):
  1360. assert_equal(
  1361. np.array(['-1980-02-29T01:02:03'], np.dtype('M8[s]')),
  1362. np.array(['-1980-02-29 01:02:03Z'], np.dtype('M8[s]')))
  1363. # Time zone offset
  1364. with assert_warns(DeprecationWarning):
  1365. assert_equal(
  1366. np.array(['1980-02-29T02:02:03'], np.dtype('M8[s]')),
  1367. np.array(['1980-02-29 00:32:03-0130'], np.dtype('M8[s]')))
  1368. with assert_warns(DeprecationWarning):
  1369. assert_equal(
  1370. np.array(['1980-02-28T22:32:03'], np.dtype('M8[s]')),
  1371. np.array(['1980-02-29 00:02:03+01:30'], np.dtype('M8[s]')))
  1372. with assert_warns(DeprecationWarning):
  1373. assert_equal(
  1374. np.array(['1980-02-29T02:32:03.506'], np.dtype('M8[s]')),
  1375. np.array(['1980-02-29 00:32:03.506-02'], np.dtype('M8[s]')))
  1376. with assert_warns(DeprecationWarning):
  1377. assert_equal(np.datetime64('1977-03-02T12:30-0230'),
  1378. np.datetime64('1977-03-02T15:00'))
  1379. def test_string_parser_error_check(self):
  1380. # Arbitrary bad string
  1381. assert_raises(ValueError, np.array, ['badvalue'], np.dtype('M8[us]'))
  1382. # Character after year must be '-'
  1383. assert_raises(ValueError, np.array, ['1980X'], np.dtype('M8[us]'))
  1384. # Cannot have trailing '-'
  1385. assert_raises(ValueError, np.array, ['1980-'], np.dtype('M8[us]'))
  1386. # Month must be in range [1,12]
  1387. assert_raises(ValueError, np.array, ['1980-00'], np.dtype('M8[us]'))
  1388. assert_raises(ValueError, np.array, ['1980-13'], np.dtype('M8[us]'))
  1389. # Month must have two digits
  1390. assert_raises(ValueError, np.array, ['1980-1'], np.dtype('M8[us]'))
  1391. assert_raises(ValueError, np.array, ['1980-1-02'], np.dtype('M8[us]'))
  1392. # 'Mor' is not a valid month
  1393. assert_raises(ValueError, np.array, ['1980-Mor'], np.dtype('M8[us]'))
  1394. # Cannot have trailing '-'
  1395. assert_raises(ValueError, np.array, ['1980-01-'], np.dtype('M8[us]'))
  1396. # Day must be in range [1,len(month)]
  1397. assert_raises(ValueError, np.array, ['1980-01-0'], np.dtype('M8[us]'))
  1398. assert_raises(ValueError, np.array, ['1980-01-00'], np.dtype('M8[us]'))
  1399. assert_raises(ValueError, np.array, ['1980-01-32'], np.dtype('M8[us]'))
  1400. assert_raises(ValueError, np.array, ['1979-02-29'], np.dtype('M8[us]'))
  1401. assert_raises(ValueError, np.array, ['1980-02-30'], np.dtype('M8[us]'))
  1402. assert_raises(ValueError, np.array, ['1980-03-32'], np.dtype('M8[us]'))
  1403. assert_raises(ValueError, np.array, ['1980-04-31'], np.dtype('M8[us]'))
  1404. assert_raises(ValueError, np.array, ['1980-05-32'], np.dtype('M8[us]'))
  1405. assert_raises(ValueError, np.array, ['1980-06-31'], np.dtype('M8[us]'))
  1406. assert_raises(ValueError, np.array, ['1980-07-32'], np.dtype('M8[us]'))
  1407. assert_raises(ValueError, np.array, ['1980-08-32'], np.dtype('M8[us]'))
  1408. assert_raises(ValueError, np.array, ['1980-09-31'], np.dtype('M8[us]'))
  1409. assert_raises(ValueError, np.array, ['1980-10-32'], np.dtype('M8[us]'))
  1410. assert_raises(ValueError, np.array, ['1980-11-31'], np.dtype('M8[us]'))
  1411. assert_raises(ValueError, np.array, ['1980-12-32'], np.dtype('M8[us]'))
  1412. # Cannot have trailing characters
  1413. assert_raises(ValueError, np.array, ['1980-02-03%'],
  1414. np.dtype('M8[us]'))
  1415. assert_raises(ValueError, np.array, ['1980-02-03 q'],
  1416. np.dtype('M8[us]'))
  1417. # Hours must be in range [0, 23]
  1418. assert_raises(ValueError, np.array, ['1980-02-03 25'],
  1419. np.dtype('M8[us]'))
  1420. assert_raises(ValueError, np.array, ['1980-02-03T25'],
  1421. np.dtype('M8[us]'))
  1422. assert_raises(ValueError, np.array, ['1980-02-03 24:01'],
  1423. np.dtype('M8[us]'))
  1424. assert_raises(ValueError, np.array, ['1980-02-03T24:01'],
  1425. np.dtype('M8[us]'))
  1426. assert_raises(ValueError, np.array, ['1980-02-03 -1'],
  1427. np.dtype('M8[us]'))
  1428. # No trailing ':'
  1429. assert_raises(ValueError, np.array, ['1980-02-03 01:'],
  1430. np.dtype('M8[us]'))
  1431. # Minutes must be in range [0, 59]
  1432. assert_raises(ValueError, np.array, ['1980-02-03 01:-1'],
  1433. np.dtype('M8[us]'))
  1434. assert_raises(ValueError, np.array, ['1980-02-03 01:60'],
  1435. np.dtype('M8[us]'))
  1436. # No trailing ':'
  1437. assert_raises(ValueError, np.array, ['1980-02-03 01:60:'],
  1438. np.dtype('M8[us]'))
  1439. # Seconds must be in range [0, 59]
  1440. assert_raises(ValueError, np.array, ['1980-02-03 01:10:-1'],
  1441. np.dtype('M8[us]'))
  1442. assert_raises(ValueError, np.array, ['1980-02-03 01:01:60'],
  1443. np.dtype('M8[us]'))
  1444. # Timezone offset must within a reasonable range
  1445. with assert_warns(DeprecationWarning):
  1446. assert_raises(ValueError, np.array, ['1980-02-03 01:01:00+0661'],
  1447. np.dtype('M8[us]'))
  1448. with assert_warns(DeprecationWarning):
  1449. assert_raises(ValueError, np.array, ['1980-02-03 01:01:00+2500'],
  1450. np.dtype('M8[us]'))
  1451. with assert_warns(DeprecationWarning):
  1452. assert_raises(ValueError, np.array, ['1980-02-03 01:01:00-0070'],
  1453. np.dtype('M8[us]'))
  1454. with assert_warns(DeprecationWarning):
  1455. assert_raises(ValueError, np.array, ['1980-02-03 01:01:00-3000'],
  1456. np.dtype('M8[us]'))
  1457. with assert_warns(DeprecationWarning):
  1458. assert_raises(ValueError, np.array, ['1980-02-03 01:01:00-25:00'],
  1459. np.dtype('M8[us]'))
  1460. def test_creation_overflow(self):
  1461. date = '1980-03-23 20:00:00'
  1462. timesteps = np.array([date], dtype='datetime64[s]')[0].astype(np.int64)
  1463. for unit in ['ms', 'us', 'ns']:
  1464. timesteps *= 1000
  1465. x = np.array([date], dtype='datetime64[%s]' % unit)
  1466. assert_equal(timesteps, x[0].astype(np.int64),
  1467. err_msg='Datetime conversion error for unit %s' % unit)
  1468. assert_equal(x[0].astype(np.int64), 322689600000000000)
  1469. # gh-13062
  1470. with pytest.raises(OverflowError):
  1471. np.datetime64(2**64, 'D')
  1472. with pytest.raises(OverflowError):
  1473. np.timedelta64(2**64, 'D')
  1474. def test_datetime_as_string(self):
  1475. # Check all the units with default string conversion
  1476. date = '1959-10-13'
  1477. datetime = '1959-10-13T12:34:56.789012345678901234'
  1478. assert_equal(np.datetime_as_string(np.datetime64(date, 'Y')),
  1479. '1959')
  1480. assert_equal(np.datetime_as_string(np.datetime64(date, 'M')),
  1481. '1959-10')
  1482. assert_equal(np.datetime_as_string(np.datetime64(date, 'D')),
  1483. '1959-10-13')
  1484. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'h')),
  1485. '1959-10-13T12')
  1486. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'm')),
  1487. '1959-10-13T12:34')
  1488. assert_equal(np.datetime_as_string(np.datetime64(datetime, 's')),
  1489. '1959-10-13T12:34:56')
  1490. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'ms')),
  1491. '1959-10-13T12:34:56.789')
  1492. for us in ['us', 'μs', b'us']: # check non-ascii and bytes too
  1493. assert_equal(np.datetime_as_string(np.datetime64(datetime, us)),
  1494. '1959-10-13T12:34:56.789012')
  1495. datetime = '1969-12-31T23:34:56.789012345678901234'
  1496. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'ns')),
  1497. '1969-12-31T23:34:56.789012345')
  1498. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'ps')),
  1499. '1969-12-31T23:34:56.789012345678')
  1500. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'fs')),
  1501. '1969-12-31T23:34:56.789012345678901')
  1502. datetime = '1969-12-31T23:59:57.789012345678901234'
  1503. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'as')),
  1504. datetime)
  1505. datetime = '1970-01-01T00:34:56.789012345678901234'
  1506. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'ns')),
  1507. '1970-01-01T00:34:56.789012345')
  1508. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'ps')),
  1509. '1970-01-01T00:34:56.789012345678')
  1510. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'fs')),
  1511. '1970-01-01T00:34:56.789012345678901')
  1512. datetime = '1970-01-01T00:00:05.789012345678901234'
  1513. assert_equal(np.datetime_as_string(np.datetime64(datetime, 'as')),
  1514. datetime)
  1515. # String conversion with the unit= parameter
  1516. a = np.datetime64('2032-07-18T12:23:34.123456', 'us')
  1517. assert_equal(np.datetime_as_string(a, unit='Y', casting='unsafe'),
  1518. '2032')
  1519. assert_equal(np.datetime_as_string(a, unit='M', casting='unsafe'),
  1520. '2032-07')
  1521. assert_equal(np.datetime_as_string(a, unit='W', casting='unsafe'),
  1522. '2032-07-18')
  1523. assert_equal(np.datetime_as_string(a, unit='D', casting='unsafe'),
  1524. '2032-07-18')
  1525. assert_equal(np.datetime_as_string(a, unit='h'), '2032-07-18T12')
  1526. assert_equal(np.datetime_as_string(a, unit='m'),
  1527. '2032-07-18T12:23')
  1528. assert_equal(np.datetime_as_string(a, unit='s'),
  1529. '2032-07-18T12:23:34')
  1530. assert_equal(np.datetime_as_string(a, unit='ms'),
  1531. '2032-07-18T12:23:34.123')
  1532. assert_equal(np.datetime_as_string(a, unit='us'),
  1533. '2032-07-18T12:23:34.123456')
  1534. assert_equal(np.datetime_as_string(a, unit='ns'),
  1535. '2032-07-18T12:23:34.123456000')
  1536. assert_equal(np.datetime_as_string(a, unit='ps'),
  1537. '2032-07-18T12:23:34.123456000000')
  1538. assert_equal(np.datetime_as_string(a, unit='fs'),
  1539. '2032-07-18T12:23:34.123456000000000')
  1540. assert_equal(np.datetime_as_string(a, unit='as'),
  1541. '2032-07-18T12:23:34.123456000000000000')
  1542. # unit='auto' parameter
  1543. assert_equal(np.datetime_as_string(
  1544. np.datetime64('2032-07-18T12:23:34.123456', 'us'), unit='auto'),
  1545. '2032-07-18T12:23:34.123456')
  1546. assert_equal(np.datetime_as_string(
  1547. np.datetime64('2032-07-18T12:23:34.12', 'us'), unit='auto'),
  1548. '2032-07-18T12:23:34.120')
  1549. assert_equal(np.datetime_as_string(
  1550. np.datetime64('2032-07-18T12:23:34', 'us'), unit='auto'),
  1551. '2032-07-18T12:23:34')
  1552. assert_equal(np.datetime_as_string(
  1553. np.datetime64('2032-07-18T12:23:00', 'us'), unit='auto'),
  1554. '2032-07-18T12:23')
  1555. # 'auto' doesn't split up hour and minute
  1556. assert_equal(np.datetime_as_string(
  1557. np.datetime64('2032-07-18T12:00:00', 'us'), unit='auto'),
  1558. '2032-07-18T12:00')
  1559. assert_equal(np.datetime_as_string(
  1560. np.datetime64('2032-07-18T00:00:00', 'us'), unit='auto'),
  1561. '2032-07-18')
  1562. # 'auto' doesn't split up the date
  1563. assert_equal(np.datetime_as_string(
  1564. np.datetime64('2032-07-01T00:00:00', 'us'), unit='auto'),
  1565. '2032-07-01')
  1566. assert_equal(np.datetime_as_string(
  1567. np.datetime64('2032-01-01T00:00:00', 'us'), unit='auto'),
  1568. '2032-01-01')
  1569. @pytest.mark.skipif(not _has_pytz, reason="The pytz module is not available.")
  1570. def test_datetime_as_string_timezone(self):
  1571. # timezone='local' vs 'UTC'
  1572. a = np.datetime64('2010-03-15T06:30', 'm')
  1573. assert_equal(np.datetime_as_string(a),
  1574. '2010-03-15T06:30')
  1575. assert_equal(np.datetime_as_string(a, timezone='naive'),
  1576. '2010-03-15T06:30')
  1577. assert_equal(np.datetime_as_string(a, timezone='UTC'),
  1578. '2010-03-15T06:30Z')
  1579. assert_(np.datetime_as_string(a, timezone='local') !=
  1580. '2010-03-15T06:30')
  1581. b = np.datetime64('2010-02-15T06:30', 'm')
  1582. assert_equal(np.datetime_as_string(a, timezone=tz('US/Central')),
  1583. '2010-03-15T01:30-0500')
  1584. assert_equal(np.datetime_as_string(a, timezone=tz('US/Eastern')),
  1585. '2010-03-15T02:30-0400')
  1586. assert_equal(np.datetime_as_string(a, timezone=tz('US/Pacific')),
  1587. '2010-03-14T23:30-0700')
  1588. assert_equal(np.datetime_as_string(b, timezone=tz('US/Central')),
  1589. '2010-02-15T00:30-0600')
  1590. assert_equal(np.datetime_as_string(b, timezone=tz('US/Eastern')),
  1591. '2010-02-15T01:30-0500')
  1592. assert_equal(np.datetime_as_string(b, timezone=tz('US/Pacific')),
  1593. '2010-02-14T22:30-0800')
  1594. # Dates to strings with a timezone attached is disabled by default
  1595. assert_raises(TypeError, np.datetime_as_string, a, unit='D',
  1596. timezone=tz('US/Pacific'))
  1597. # Check that we can print out the date in the specified time zone
  1598. assert_equal(np.datetime_as_string(a, unit='D',
  1599. timezone=tz('US/Pacific'), casting='unsafe'),
  1600. '2010-03-14')
  1601. assert_equal(np.datetime_as_string(b, unit='D',
  1602. timezone=tz('US/Central'), casting='unsafe'),
  1603. '2010-02-15')
  1604. def test_datetime_arange(self):
  1605. # With two datetimes provided as strings
  1606. a = np.arange('2010-01-05', '2010-01-10', dtype='M8[D]')
  1607. assert_equal(a.dtype, np.dtype('M8[D]'))
  1608. assert_equal(a,
  1609. np.array(['2010-01-05', '2010-01-06', '2010-01-07',
  1610. '2010-01-08', '2010-01-09'], dtype='M8[D]'))
  1611. a = np.arange('1950-02-10', '1950-02-06', -1, dtype='M8[D]')
  1612. assert_equal(a.dtype, np.dtype('M8[D]'))
  1613. assert_equal(a,
  1614. np.array(['1950-02-10', '1950-02-09', '1950-02-08',
  1615. '1950-02-07'], dtype='M8[D]'))
  1616. # Unit should be detected as months here
  1617. a = np.arange('1969-05', '1970-05', 2, dtype='M8')
  1618. assert_equal(a.dtype, np.dtype('M8[M]'))
  1619. assert_equal(a,
  1620. np.datetime64('1969-05') + np.arange(12, step=2))
  1621. # datetime, integer|timedelta works as well
  1622. # produces arange (start, start + stop) in this case
  1623. a = np.arange('1969', 18, 3, dtype='M8')
  1624. assert_equal(a.dtype, np.dtype('M8[Y]'))
  1625. assert_equal(a,
  1626. np.datetime64('1969') + np.arange(18, step=3))
  1627. a = np.arange('1969-12-19', 22, np.timedelta64(2), dtype='M8')
  1628. assert_equal(a.dtype, np.dtype('M8[D]'))
  1629. assert_equal(a,
  1630. np.datetime64('1969-12-19') + np.arange(22, step=2))
  1631. # Step of 0 is disallowed
  1632. assert_raises(ValueError, np.arange, np.datetime64('today'),
  1633. np.datetime64('today') + 3, 0)
  1634. # Promotion across nonlinear unit boundaries is disallowed
  1635. assert_raises(TypeError, np.arange, np.datetime64('2011-03-01', 'D'),
  1636. np.timedelta64(5, 'M'))
  1637. assert_raises(TypeError, np.arange,
  1638. np.datetime64('2012-02-03T14', 's'),
  1639. np.timedelta64(5, 'Y'))
  1640. def test_datetime_arange_no_dtype(self):
  1641. d = np.array('2010-01-04', dtype="M8[D]")
  1642. assert_equal(np.arange(d, d + 1), d)
  1643. assert_raises(ValueError, np.arange, d)
  1644. def test_timedelta_arange(self):
  1645. a = np.arange(3, 10, dtype='m8')
  1646. assert_equal(a.dtype, np.dtype('m8'))
  1647. assert_equal(a, np.timedelta64(0) + np.arange(3, 10))
  1648. a = np.arange(np.timedelta64(3, 's'), 10, 2, dtype='m8')
  1649. assert_equal(a.dtype, np.dtype('m8[s]'))
  1650. assert_equal(a, np.timedelta64(0, 's') + np.arange(3, 10, 2))
  1651. # Step of 0 is disallowed
  1652. assert_raises(ValueError, np.arange, np.timedelta64(0),
  1653. np.timedelta64(5), 0)
  1654. # Promotion across nonlinear unit boundaries is disallowed
  1655. assert_raises(TypeError, np.arange, np.timedelta64(0, 'D'),
  1656. np.timedelta64(5, 'M'))
  1657. assert_raises(TypeError, np.arange, np.timedelta64(0, 'Y'),
  1658. np.timedelta64(5, 'D'))
  1659. @pytest.mark.parametrize("val1, val2, expected", [
  1660. # case from gh-12092
  1661. (np.timedelta64(7, 's'),
  1662. np.timedelta64(3, 's'),
  1663. np.timedelta64(1, 's')),
  1664. # negative value cases
  1665. (np.timedelta64(3, 's'),
  1666. np.timedelta64(-2, 's'),
  1667. np.timedelta64(-1, 's')),
  1668. (np.timedelta64(-3, 's'),
  1669. np.timedelta64(2, 's'),
  1670. np.timedelta64(1, 's')),
  1671. # larger value cases
  1672. (np.timedelta64(17, 's'),
  1673. np.timedelta64(22, 's'),
  1674. np.timedelta64(17, 's')),
  1675. (np.timedelta64(22, 's'),
  1676. np.timedelta64(17, 's'),
  1677. np.timedelta64(5, 's')),
  1678. # different units
  1679. (np.timedelta64(1, 'm'),
  1680. np.timedelta64(57, 's'),
  1681. np.timedelta64(3, 's')),
  1682. (np.timedelta64(1, 'us'),
  1683. np.timedelta64(727, 'ns'),
  1684. np.timedelta64(273, 'ns')),
  1685. # NaT is propagated
  1686. (np.timedelta64('NaT'),
  1687. np.timedelta64(50, 'ns'),
  1688. np.timedelta64('NaT')),
  1689. # Y % M works
  1690. (np.timedelta64(2, 'Y'),
  1691. np.timedelta64(22, 'M'),
  1692. np.timedelta64(2, 'M')),
  1693. ])
  1694. def test_timedelta_modulus(self, val1, val2, expected):
  1695. assert_equal(val1 % val2, expected)
  1696. @pytest.mark.parametrize("val1, val2", [
  1697. # years and months sometimes can't be unambiguously
  1698. # divided for modulus operation
  1699. (np.timedelta64(7, 'Y'),
  1700. np.timedelta64(3, 's')),
  1701. (np.timedelta64(7, 'M'),
  1702. np.timedelta64(1, 'D')),
  1703. ])
  1704. def test_timedelta_modulus_error(self, val1, val2):
  1705. with assert_raises_regex(TypeError, "common metadata divisor"):
  1706. val1 % val2
  1707. def test_timedelta_modulus_div_by_zero(self):
  1708. with assert_warns(RuntimeWarning):
  1709. actual = np.timedelta64(10, 's') % np.timedelta64(0, 's')
  1710. assert_equal(actual, np.timedelta64('NaT'))
  1711. @pytest.mark.parametrize("val1, val2", [
  1712. # cases where one operand is not
  1713. # timedelta64
  1714. (np.timedelta64(7, 'Y'),
  1715. 15,),
  1716. (7.5,
  1717. np.timedelta64(1, 'D')),
  1718. ])
  1719. def test_timedelta_modulus_type_resolution(self, val1, val2):
  1720. # NOTE: some of the operations may be supported
  1721. # in the future
  1722. with assert_raises_regex(TypeError,
  1723. "'remainder' cannot use operands with types"):
  1724. val1 % val2
  1725. def test_timedelta_arange_no_dtype(self):
  1726. d = np.array(5, dtype="m8[D]")
  1727. assert_equal(np.arange(d, d + 1), d)
  1728. assert_equal(np.arange(d), np.arange(0, d))
  1729. def test_datetime_maximum_reduce(self):
  1730. a = np.array(['2010-01-02', '1999-03-14', '1833-03'], dtype='M8[D]')
  1731. assert_equal(np.maximum.reduce(a).dtype, np.dtype('M8[D]'))
  1732. assert_equal(np.maximum.reduce(a),
  1733. np.datetime64('2010-01-02'))
  1734. a = np.array([1, 4, 0, 7, 2], dtype='m8[s]')
  1735. assert_equal(np.maximum.reduce(a).dtype, np.dtype('m8[s]'))
  1736. assert_equal(np.maximum.reduce(a),
  1737. np.timedelta64(7, 's'))
  1738. def test_datetime_busday_offset(self):
  1739. # First Monday in June
  1740. assert_equal(
  1741. np.busday_offset('2011-06', 0, roll='forward', weekmask='Mon'),
  1742. np.datetime64('2011-06-06'))
  1743. # Last Monday in June
  1744. assert_equal(
  1745. np.busday_offset('2011-07', -1, roll='forward', weekmask='Mon'),
  1746. np.datetime64('2011-06-27'))
  1747. assert_equal(
  1748. np.busday_offset('2011-07', -1, roll='forward', weekmask='Mon'),
  1749. np.datetime64('2011-06-27'))
  1750. # Default M-F business days, different roll modes
  1751. assert_equal(np.busday_offset('2010-08', 0, roll='backward'),
  1752. np.datetime64('2010-07-30'))
  1753. assert_equal(np.busday_offset('2010-08', 0, roll='preceding'),
  1754. np.datetime64('2010-07-30'))
  1755. assert_equal(np.busday_offset('2010-08', 0, roll='modifiedpreceding'),
  1756. np.datetime64('2010-08-02'))
  1757. assert_equal(np.busday_offset('2010-08', 0, roll='modifiedfollowing'),
  1758. np.datetime64('2010-08-02'))
  1759. assert_equal(np.busday_offset('2010-08', 0, roll='forward'),
  1760. np.datetime64('2010-08-02'))
  1761. assert_equal(np.busday_offset('2010-08', 0, roll='following'),
  1762. np.datetime64('2010-08-02'))
  1763. assert_equal(np.busday_offset('2010-10-30', 0, roll='following'),
  1764. np.datetime64('2010-11-01'))
  1765. assert_equal(
  1766. np.busday_offset('2010-10-30', 0, roll='modifiedfollowing'),
  1767. np.datetime64('2010-10-29'))
  1768. assert_equal(
  1769. np.busday_offset('2010-10-30', 0, roll='modifiedpreceding'),
  1770. np.datetime64('2010-10-29'))
  1771. assert_equal(
  1772. np.busday_offset('2010-10-16', 0, roll='modifiedfollowing'),
  1773. np.datetime64('2010-10-18'))
  1774. assert_equal(
  1775. np.busday_offset('2010-10-16', 0, roll='modifiedpreceding'),
  1776. np.datetime64('2010-10-15'))
  1777. # roll='raise' by default
  1778. assert_raises(ValueError, np.busday_offset, '2011-06-04', 0)
  1779. # Bigger offset values
  1780. assert_equal(np.busday_offset('2006-02-01', 25),
  1781. np.datetime64('2006-03-08'))
  1782. assert_equal(np.busday_offset('2006-03-08', -25),
  1783. np.datetime64('2006-02-01'))
  1784. assert_equal(np.busday_offset('2007-02-25', 11, weekmask='SatSun'),
  1785. np.datetime64('2007-04-07'))
  1786. assert_equal(np.busday_offset('2007-04-07', -11, weekmask='SatSun'),
  1787. np.datetime64('2007-02-25'))
  1788. # NaT values when roll is not raise
  1789. assert_equal(np.busday_offset(np.datetime64('NaT'), 1, roll='nat'),
  1790. np.datetime64('NaT'))
  1791. assert_equal(np.busday_offset(np.datetime64('NaT'), 1, roll='following'),
  1792. np.datetime64('NaT'))
  1793. assert_equal(np.busday_offset(np.datetime64('NaT'), 1, roll='preceding'),
  1794. np.datetime64('NaT'))
  1795. def test_datetime_busdaycalendar(self):
  1796. # Check that it removes NaT, duplicates, and weekends
  1797. # and sorts the result.
  1798. bdd = np.busdaycalendar(
  1799. holidays=['NaT', '2011-01-17', '2011-03-06', 'NaT',
  1800. '2011-12-26', '2011-05-30', '2011-01-17'])
  1801. assert_equal(bdd.holidays,
  1802. np.array(['2011-01-17', '2011-05-30', '2011-12-26'], dtype='M8'))
  1803. # Default M-F weekmask
  1804. assert_equal(bdd.weekmask, np.array([1, 1, 1, 1, 1, 0, 0], dtype='?'))
  1805. # Check string weekmask with varying whitespace.
  1806. bdd = np.busdaycalendar(weekmask="Sun TueWed Thu\tFri")
  1807. assert_equal(bdd.weekmask, np.array([0, 1, 1, 1, 1, 0, 1], dtype='?'))
  1808. # Check length 7 0/1 string
  1809. bdd = np.busdaycalendar(weekmask="0011001")
  1810. assert_equal(bdd.weekmask, np.array([0, 0, 1, 1, 0, 0, 1], dtype='?'))
  1811. # Check length 7 string weekmask.
  1812. bdd = np.busdaycalendar(weekmask="Mon Tue")
  1813. assert_equal(bdd.weekmask, np.array([1, 1, 0, 0, 0, 0, 0], dtype='?'))
  1814. # All-zeros weekmask should raise
  1815. assert_raises(ValueError, np.busdaycalendar, weekmask=[0, 0, 0, 0, 0, 0, 0])
  1816. # weekday names must be correct case
  1817. assert_raises(ValueError, np.busdaycalendar, weekmask="satsun")
  1818. # All-zeros weekmask should raise
  1819. assert_raises(ValueError, np.busdaycalendar, weekmask="")
  1820. # Invalid weekday name codes should raise
  1821. assert_raises(ValueError, np.busdaycalendar, weekmask="Mon Tue We")
  1822. assert_raises(ValueError, np.busdaycalendar, weekmask="Max")
  1823. assert_raises(ValueError, np.busdaycalendar, weekmask="Monday Tue")
  1824. def test_datetime_busday_holidays_offset(self):
  1825. # With exactly one holiday
  1826. assert_equal(
  1827. np.busday_offset('2011-11-10', 1, holidays=['2011-11-11']),
  1828. np.datetime64('2011-11-14'))
  1829. assert_equal(
  1830. np.busday_offset('2011-11-04', 5, holidays=['2011-11-11']),
  1831. np.datetime64('2011-11-14'))
  1832. assert_equal(
  1833. np.busday_offset('2011-11-10', 5, holidays=['2011-11-11']),
  1834. np.datetime64('2011-11-18'))
  1835. assert_equal(
  1836. np.busday_offset('2011-11-14', -1, holidays=['2011-11-11']),
  1837. np.datetime64('2011-11-10'))
  1838. assert_equal(
  1839. np.busday_offset('2011-11-18', -5, holidays=['2011-11-11']),
  1840. np.datetime64('2011-11-10'))
  1841. assert_equal(
  1842. np.busday_offset('2011-11-14', -5, holidays=['2011-11-11']),
  1843. np.datetime64('2011-11-04'))
  1844. # With the holiday appearing twice
  1845. assert_equal(
  1846. np.busday_offset('2011-11-10', 1,
  1847. holidays=['2011-11-11', '2011-11-11']),
  1848. np.datetime64('2011-11-14'))
  1849. assert_equal(
  1850. np.busday_offset('2011-11-14', -1,
  1851. holidays=['2011-11-11', '2011-11-11']),
  1852. np.datetime64('2011-11-10'))
  1853. # With a NaT holiday
  1854. assert_equal(
  1855. np.busday_offset('2011-11-10', 1,
  1856. holidays=['2011-11-11', 'NaT']),
  1857. np.datetime64('2011-11-14'))
  1858. assert_equal(
  1859. np.busday_offset('2011-11-14', -1,
  1860. holidays=['NaT', '2011-11-11']),
  1861. np.datetime64('2011-11-10'))
  1862. # With another holiday after
  1863. assert_equal(
  1864. np.busday_offset('2011-11-10', 1,
  1865. holidays=['2011-11-11', '2011-11-24']),
  1866. np.datetime64('2011-11-14'))
  1867. assert_equal(
  1868. np.busday_offset('2011-11-14', -1,
  1869. holidays=['2011-11-11', '2011-11-24']),
  1870. np.datetime64('2011-11-10'))
  1871. # With another holiday before
  1872. assert_equal(
  1873. np.busday_offset('2011-11-10', 1,
  1874. holidays=['2011-10-10', '2011-11-11']),
  1875. np.datetime64('2011-11-14'))
  1876. assert_equal(
  1877. np.busday_offset('2011-11-14', -1,
  1878. holidays=['2011-10-10', '2011-11-11']),
  1879. np.datetime64('2011-11-10'))
  1880. # With another holiday before and after
  1881. assert_equal(
  1882. np.busday_offset('2011-11-10', 1,
  1883. holidays=['2011-10-10', '2011-11-11', '2011-11-24']),
  1884. np.datetime64('2011-11-14'))
  1885. assert_equal(
  1886. np.busday_offset('2011-11-14', -1,
  1887. holidays=['2011-10-10', '2011-11-11', '2011-11-24']),
  1888. np.datetime64('2011-11-10'))
  1889. # A bigger forward jump across more than one week/holiday
  1890. holidays = ['2011-10-10', '2011-11-11', '2011-11-24',
  1891. '2011-12-25', '2011-05-30', '2011-02-21',
  1892. '2011-12-26', '2012-01-02']
  1893. bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays)
  1894. assert_equal(
  1895. np.busday_offset('2011-10-03', 4, holidays=holidays),
  1896. np.busday_offset('2011-10-03', 4))
  1897. assert_equal(
  1898. np.busday_offset('2011-10-03', 5, holidays=holidays),
  1899. np.busday_offset('2011-10-03', 5 + 1))
  1900. assert_equal(
  1901. np.busday_offset('2011-10-03', 27, holidays=holidays),
  1902. np.busday_offset('2011-10-03', 27 + 1))
  1903. assert_equal(
  1904. np.busday_offset('2011-10-03', 28, holidays=holidays),
  1905. np.busday_offset('2011-10-03', 28 + 2))
  1906. assert_equal(
  1907. np.busday_offset('2011-10-03', 35, holidays=holidays),
  1908. np.busday_offset('2011-10-03', 35 + 2))
  1909. assert_equal(
  1910. np.busday_offset('2011-10-03', 36, holidays=holidays),
  1911. np.busday_offset('2011-10-03', 36 + 3))
  1912. assert_equal(
  1913. np.busday_offset('2011-10-03', 56, holidays=holidays),
  1914. np.busday_offset('2011-10-03', 56 + 3))
  1915. assert_equal(
  1916. np.busday_offset('2011-10-03', 57, holidays=holidays),
  1917. np.busday_offset('2011-10-03', 57 + 4))
  1918. assert_equal(
  1919. np.busday_offset('2011-10-03', 60, holidays=holidays),
  1920. np.busday_offset('2011-10-03', 60 + 4))
  1921. assert_equal(
  1922. np.busday_offset('2011-10-03', 61, holidays=holidays),
  1923. np.busday_offset('2011-10-03', 61 + 5))
  1924. assert_equal(
  1925. np.busday_offset('2011-10-03', 61, busdaycal=bdd),
  1926. np.busday_offset('2011-10-03', 61 + 5))
  1927. # A bigger backward jump across more than one week/holiday
  1928. assert_equal(
  1929. np.busday_offset('2012-01-03', -1, holidays=holidays),
  1930. np.busday_offset('2012-01-03', -1 - 1))
  1931. assert_equal(
  1932. np.busday_offset('2012-01-03', -4, holidays=holidays),
  1933. np.busday_offset('2012-01-03', -4 - 1))
  1934. assert_equal(
  1935. np.busday_offset('2012-01-03', -5, holidays=holidays),
  1936. np.busday_offset('2012-01-03', -5 - 2))
  1937. assert_equal(
  1938. np.busday_offset('2012-01-03', -25, holidays=holidays),
  1939. np.busday_offset('2012-01-03', -25 - 2))
  1940. assert_equal(
  1941. np.busday_offset('2012-01-03', -26, holidays=holidays),
  1942. np.busday_offset('2012-01-03', -26 - 3))
  1943. assert_equal(
  1944. np.busday_offset('2012-01-03', -33, holidays=holidays),
  1945. np.busday_offset('2012-01-03', -33 - 3))
  1946. assert_equal(
  1947. np.busday_offset('2012-01-03', -34, holidays=holidays),
  1948. np.busday_offset('2012-01-03', -34 - 4))
  1949. assert_equal(
  1950. np.busday_offset('2012-01-03', -56, holidays=holidays),
  1951. np.busday_offset('2012-01-03', -56 - 4))
  1952. assert_equal(
  1953. np.busday_offset('2012-01-03', -57, holidays=holidays),
  1954. np.busday_offset('2012-01-03', -57 - 5))
  1955. assert_equal(
  1956. np.busday_offset('2012-01-03', -57, busdaycal=bdd),
  1957. np.busday_offset('2012-01-03', -57 - 5))
  1958. # Can't supply both a weekmask/holidays and busdaycal
  1959. assert_raises(ValueError, np.busday_offset, '2012-01-03', -15,
  1960. weekmask='1111100', busdaycal=bdd)
  1961. assert_raises(ValueError, np.busday_offset, '2012-01-03', -15,
  1962. holidays=holidays, busdaycal=bdd)
  1963. # Roll with the holidays
  1964. assert_equal(
  1965. np.busday_offset('2011-12-25', 0,
  1966. roll='forward', holidays=holidays),
  1967. np.datetime64('2011-12-27'))
  1968. assert_equal(
  1969. np.busday_offset('2011-12-26', 0,
  1970. roll='forward', holidays=holidays),
  1971. np.datetime64('2011-12-27'))
  1972. assert_equal(
  1973. np.busday_offset('2011-12-26', 0,
  1974. roll='backward', holidays=holidays),
  1975. np.datetime64('2011-12-23'))
  1976. assert_equal(
  1977. np.busday_offset('2012-02-27', 0,
  1978. roll='modifiedfollowing',
  1979. holidays=['2012-02-27', '2012-02-26', '2012-02-28',
  1980. '2012-03-01', '2012-02-29']),
  1981. np.datetime64('2012-02-24'))
  1982. assert_equal(
  1983. np.busday_offset('2012-03-06', 0,
  1984. roll='modifiedpreceding',
  1985. holidays=['2012-03-02', '2012-03-03', '2012-03-01',
  1986. '2012-03-05', '2012-03-07', '2012-03-06']),
  1987. np.datetime64('2012-03-08'))
  1988. def test_datetime_busday_holidays_count(self):
  1989. holidays = ['2011-01-01', '2011-10-10', '2011-11-11', '2011-11-24',
  1990. '2011-12-25', '2011-05-30', '2011-02-21', '2011-01-17',
  1991. '2011-12-26', '2012-01-02', '2011-02-21', '2011-05-30',
  1992. '2011-07-01', '2011-07-04', '2011-09-05', '2011-10-10']
  1993. bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays)
  1994. # Validate against busday_offset broadcast against
  1995. # a range of offsets
  1996. dates = np.busday_offset('2011-01-01', np.arange(366),
  1997. roll='forward', busdaycal=bdd)
  1998. assert_equal(np.busday_count('2011-01-01', dates, busdaycal=bdd),
  1999. np.arange(366))
  2000. # Returns negative value when reversed
  2001. assert_equal(np.busday_count(dates, '2011-01-01', busdaycal=bdd),
  2002. -np.arange(366))
  2003. dates = np.busday_offset('2011-12-31', -np.arange(366),
  2004. roll='forward', busdaycal=bdd)
  2005. assert_equal(np.busday_count(dates, '2011-12-31', busdaycal=bdd),
  2006. np.arange(366))
  2007. # Returns negative value when reversed
  2008. assert_equal(np.busday_count('2011-12-31', dates, busdaycal=bdd),
  2009. -np.arange(366))
  2010. # Can't supply both a weekmask/holidays and busdaycal
  2011. assert_raises(ValueError, np.busday_offset, '2012-01-03', '2012-02-03',
  2012. weekmask='1111100', busdaycal=bdd)
  2013. assert_raises(ValueError, np.busday_offset, '2012-01-03', '2012-02-03',
  2014. holidays=holidays, busdaycal=bdd)
  2015. # Number of Mondays in March 2011
  2016. assert_equal(np.busday_count('2011-03', '2011-04', weekmask='Mon'), 4)
  2017. # Returns negative value when reversed
  2018. assert_equal(np.busday_count('2011-04', '2011-03', weekmask='Mon'), -4)
  2019. def test_datetime_is_busday(self):
  2020. holidays = ['2011-01-01', '2011-10-10', '2011-11-11', '2011-11-24',
  2021. '2011-12-25', '2011-05-30', '2011-02-21', '2011-01-17',
  2022. '2011-12-26', '2012-01-02', '2011-02-21', '2011-05-30',
  2023. '2011-07-01', '2011-07-04', '2011-09-05', '2011-10-10',
  2024. 'NaT']
  2025. bdd = np.busdaycalendar(weekmask='1111100', holidays=holidays)
  2026. # Weekend/weekday tests
  2027. assert_equal(np.is_busday('2011-01-01'), False)
  2028. assert_equal(np.is_busday('2011-01-02'), False)
  2029. assert_equal(np.is_busday('2011-01-03'), True)
  2030. # All the holidays are not business days
  2031. assert_equal(np.is_busday(holidays, busdaycal=bdd),
  2032. np.zeros(len(holidays), dtype='?'))
  2033. def test_datetime_y2038(self):
  2034. # Test parsing on either side of the Y2038 boundary
  2035. a = np.datetime64('2038-01-19T03:14:07')
  2036. assert_equal(a.view(np.int64), 2**31 - 1)
  2037. a = np.datetime64('2038-01-19T03:14:08')
  2038. assert_equal(a.view(np.int64), 2**31)
  2039. # Test parsing on either side of the Y2038 boundary with
  2040. # a manually specified timezone offset
  2041. with assert_warns(DeprecationWarning):
  2042. a = np.datetime64('2038-01-19T04:14:07+0100')
  2043. assert_equal(a.view(np.int64), 2**31 - 1)
  2044. with assert_warns(DeprecationWarning):
  2045. a = np.datetime64('2038-01-19T04:14:08+0100')
  2046. assert_equal(a.view(np.int64), 2**31)
  2047. # Test parsing a date after Y2038
  2048. a = np.datetime64('2038-01-20T13:21:14')
  2049. assert_equal(str(a), '2038-01-20T13:21:14')
  2050. def test_isnat(self):
  2051. assert_(np.isnat(np.datetime64('NaT', 'ms')))
  2052. assert_(np.isnat(np.datetime64('NaT', 'ns')))
  2053. assert_(not np.isnat(np.datetime64('2038-01-19T03:14:07')))
  2054. assert_(np.isnat(np.timedelta64('NaT', "ms")))
  2055. assert_(not np.isnat(np.timedelta64(34, "ms")))
  2056. res = np.array([False, False, True])
  2057. for unit in ['Y', 'M', 'W', 'D',
  2058. 'h', 'm', 's', 'ms', 'us',
  2059. 'ns', 'ps', 'fs', 'as']:
  2060. arr = np.array([123, -321, "NaT"], dtype='<datetime64[%s]' % unit)
  2061. assert_equal(np.isnat(arr), res)
  2062. arr = np.array([123, -321, "NaT"], dtype='>datetime64[%s]' % unit)
  2063. assert_equal(np.isnat(arr), res)
  2064. arr = np.array([123, -321, "NaT"], dtype='<timedelta64[%s]' % unit)
  2065. assert_equal(np.isnat(arr), res)
  2066. arr = np.array([123, -321, "NaT"], dtype='>timedelta64[%s]' % unit)
  2067. assert_equal(np.isnat(arr), res)
  2068. def test_isnat_error(self):
  2069. # Test that only datetime dtype arrays are accepted
  2070. for t in np.typecodes["All"]:
  2071. if t in np.typecodes["Datetime"]:
  2072. continue
  2073. assert_raises(TypeError, np.isnat, np.zeros(10, t))
  2074. def test_isfinite_scalar(self):
  2075. assert_(not np.isfinite(np.datetime64('NaT', 'ms')))
  2076. assert_(not np.isfinite(np.datetime64('NaT', 'ns')))
  2077. assert_(np.isfinite(np.datetime64('2038-01-19T03:14:07')))
  2078. assert_(not np.isfinite(np.timedelta64('NaT', "ms")))
  2079. assert_(np.isfinite(np.timedelta64(34, "ms")))
  2080. @pytest.mark.parametrize('unit', ['Y', 'M', 'W', 'D', 'h', 'm', 's', 'ms',
  2081. 'us', 'ns', 'ps', 'fs', 'as'])
  2082. @pytest.mark.parametrize('dstr', ['<datetime64[%s]', '>datetime64[%s]',
  2083. '<timedelta64[%s]', '>timedelta64[%s]'])
  2084. def test_isfinite_isinf_isnan_units(self, unit, dstr):
  2085. '''check isfinite, isinf, isnan for all units of <M, >M, <m, >m dtypes
  2086. '''
  2087. arr_val = [123, -321, "NaT"]
  2088. arr = np.array(arr_val, dtype= dstr % unit)
  2089. pos = np.array([True, True, False])
  2090. neg = np.array([False, False, True])
  2091. false = np.array([False, False, False])
  2092. assert_equal(np.isfinite(arr), pos)
  2093. assert_equal(np.isinf(arr), false)
  2094. assert_equal(np.isnan(arr), neg)
  2095. def test_assert_equal(self):
  2096. assert_raises(AssertionError, assert_equal,
  2097. np.datetime64('nat'), np.timedelta64('nat'))
  2098. def test_corecursive_input(self):
  2099. # construct a co-recursive list
  2100. a, b = [], []
  2101. a.append(b)
  2102. b.append(a)
  2103. obj_arr = np.array([None])
  2104. obj_arr[0] = a
  2105. # At some point this caused a stack overflow (gh-11154). Now raises
  2106. # ValueError since the nested list cannot be converted to a datetime.
  2107. assert_raises(ValueError, obj_arr.astype, 'M8')
  2108. assert_raises(ValueError, obj_arr.astype, 'm8')
  2109. @pytest.mark.parametrize("shape", [(), (1,)])
  2110. def test_discovery_from_object_array(self, shape):
  2111. arr = np.array("2020-10-10", dtype=object).reshape(shape)
  2112. res = np.array("2020-10-10", dtype="M8").reshape(shape)
  2113. assert res.dtype == np.dtype("M8[D]")
  2114. assert_equal(arr.astype("M8"), res)
  2115. arr[...] = np.bytes_("2020-10-10") # try a numpy string type
  2116. assert_equal(arr.astype("M8"), res)
  2117. arr = arr.astype("S")
  2118. assert_equal(arr.astype("S").astype("M8"), res)
  2119. @pytest.mark.parametrize("time_unit", [
  2120. "Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps", "fs", "as",
  2121. # compound units
  2122. "10D", "2M",
  2123. ])
  2124. def test_limit_symmetry(self, time_unit):
  2125. """
  2126. Dates should have symmetric limits around the unix epoch at +/-np.int64
  2127. """
  2128. epoch = np.datetime64(0, time_unit)
  2129. latest = np.datetime64(np.iinfo(np.int64).max, time_unit)
  2130. earliest = np.datetime64(-np.iinfo(np.int64).max, time_unit)
  2131. # above should not have overflowed
  2132. assert earliest < epoch < latest
  2133. @pytest.mark.parametrize("time_unit", [
  2134. "Y", "M",
  2135. pytest.param("W", marks=pytest.mark.xfail(reason="gh-13197")),
  2136. "D", "h", "m",
  2137. "s", "ms", "us", "ns", "ps", "fs", "as",
  2138. pytest.param("10D", marks=pytest.mark.xfail(reason="similar to gh-13197")),
  2139. ])
  2140. @pytest.mark.parametrize("sign", [-1, 1])
  2141. def test_limit_str_roundtrip(self, time_unit, sign):
  2142. """
  2143. Limits should roundtrip when converted to strings.
  2144. This tests the conversion to and from npy_datetimestruct.
  2145. """
  2146. # TODO: add absolute (gold standard) time span limit strings
  2147. limit = np.datetime64(np.iinfo(np.int64).max * sign, time_unit)
  2148. # Convert to string and back. Explicit unit needed since the day and
  2149. # week reprs are not distinguishable.
  2150. limit_via_str = np.datetime64(str(limit), time_unit)
  2151. assert limit_via_str == limit
  2152. class TestDateTimeData:
  2153. def test_basic(self):
  2154. a = np.array(['1980-03-23'], dtype=np.datetime64)
  2155. assert_equal(np.datetime_data(a.dtype), ('D', 1))
  2156. def test_bytes(self):
  2157. # byte units are converted to unicode
  2158. dt = np.datetime64('2000', (b'ms', 5))
  2159. assert np.datetime_data(dt.dtype) == ('ms', 5)
  2160. dt = np.datetime64('2000', b'5ms')
  2161. assert np.datetime_data(dt.dtype) == ('ms', 5)
  2162. def test_non_ascii(self):
  2163. # μs is normalized to μ
  2164. dt = np.datetime64('2000', ('μs', 5))
  2165. assert np.datetime_data(dt.dtype) == ('us', 5)
  2166. dt = np.datetime64('2000', '5μs')
  2167. assert np.datetime_data(dt.dtype) == ('us', 5)