test_pandas_bridge.py 107 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684
  1. # -*- coding: utf-8 -*-
  2. """
  3. Unit tests for the pandas bridge module.
  4. :copyright: Copyright 2014-2016 by the Elephant team, see AUTHORS.txt.
  5. :license: Modified BSD, see LICENSE.txt for details.
  6. """
  7. from __future__ import division, print_function
  8. import unittest
  9. from itertools import chain
  10. from neo.test.generate_datasets import fake_neo
  11. import numpy as np
  12. from numpy.testing.utils import assert_array_equal
  13. import quantities as pq
  14. try:
  15. import pandas as pd
  16. from pandas.util.testing import assert_frame_equal, assert_index_equal
  17. except ImportError:
  18. HAVE_PANDAS = False
  19. else:
  20. import elephant.pandas_bridge as ep
  21. HAVE_PANDAS = True
  22. if HAVE_PANDAS:
  23. # Currying, otherwise the unittest will break with pandas>=0.16.0
  24. # parameter check_names is introduced in a newer versions than 0.14.0
  25. # this test is written for pandas 0.14.0
  26. def assert_index_equal(left, right):
  27. try:
  28. # pandas>=0.16.0
  29. return pd.util.testing.assert_index_equal(left, right,
  30. check_names=False)
  31. except TypeError:
  32. # pandas older version
  33. return pd.util.testing.assert_index_equal(left, right)
  34. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  35. class MultiindexFromDictTestCase(unittest.TestCase):
  36. def test__multiindex_from_dict(self):
  37. inds = {'test1': 6.5,
  38. 'test2': 5,
  39. 'test3': 'test'}
  40. targ = pd.MultiIndex(levels=[[6.5], [5], ['test']],
  41. labels=[[0], [0], [0]],
  42. names=['test1', 'test2', 'test3'])
  43. res0 = ep._multiindex_from_dict(inds)
  44. self.assertEqual(targ.levels, res0.levels)
  45. self.assertEqual(targ.names, res0.names)
  46. self.assertEqual(targ.labels, res0.labels)
  47. def _convert_levels(levels):
  48. """Convert a list of levels to the format pandas returns for a MultiIndex.
  49. Parameters
  50. ----------
  51. levels : list
  52. The list of levels to convert.
  53. Returns
  54. -------
  55. list
  56. The the level in `list` converted to values like what pandas will give.
  57. """
  58. levels = list(levels)
  59. for i, level in enumerate(levels):
  60. if hasattr(level, 'lower'):
  61. try:
  62. level = unicode(level)
  63. except NameError:
  64. pass
  65. elif hasattr(level, 'date'):
  66. levels[i] = pd.DatetimeIndex(data=[level])
  67. continue
  68. elif level is None:
  69. levels[i] = pd.Index([])
  70. continue
  71. # pd.Index around pd.Index to convert to Index structure if MultiIndex
  72. levels[i] = pd.Index(pd.Index([level]))
  73. return levels
  74. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  75. class ConvertValueSafeTestCase(unittest.TestCase):
  76. def test__convert_value_safe__float(self):
  77. targ = 5.5
  78. value = targ
  79. res = ep._convert_value_safe(value)
  80. self.assertIs(res, targ)
  81. def test__convert_value_safe__str(self):
  82. targ = 'test'
  83. value = targ
  84. res = ep._convert_value_safe(value)
  85. self.assertIs(res, targ)
  86. def test__convert_value_safe__bytes(self):
  87. targ = 'test'
  88. value = b'test'
  89. res = ep._convert_value_safe(value)
  90. self.assertEqual(res, targ)
  91. def test__convert_value_safe__numpy_int_scalar(self):
  92. targ = 5
  93. value = np.array(5)
  94. res = ep._convert_value_safe(value)
  95. self.assertEqual(res, targ)
  96. self.assertFalse(hasattr(res, 'dtype'))
  97. def test__convert_value_safe__numpy_float_scalar(self):
  98. targ = 5.
  99. value = np.array(5.)
  100. res = ep._convert_value_safe(value)
  101. self.assertEqual(res, targ)
  102. self.assertFalse(hasattr(res, 'dtype'))
  103. def test__convert_value_safe__numpy_unicode_scalar(self):
  104. targ = u'test'
  105. value = np.array('test', dtype='U')
  106. res = ep._convert_value_safe(value)
  107. self.assertEqual(res, targ)
  108. self.assertFalse(hasattr(res, 'dtype'))
  109. def test__convert_value_safe__numpy_str_scalar(self):
  110. targ = u'test'
  111. value = np.array('test', dtype='S')
  112. res = ep._convert_value_safe(value)
  113. self.assertEqual(res, targ)
  114. self.assertFalse(hasattr(res, 'dtype'))
  115. def test__convert_value_safe__quantity_scalar(self):
  116. targ = (10., 'ms')
  117. value = 10. * pq.ms
  118. res = ep._convert_value_safe(value)
  119. self.assertEqual(res, targ)
  120. self.assertFalse(hasattr(res[0], 'dtype'))
  121. self.assertFalse(hasattr(res[0], 'units'))
  122. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  123. class SpiketrainToDataframeTestCase(unittest.TestCase):
  124. def test__spiketrain_to_dataframe__parents_empty(self):
  125. obj = fake_neo('SpikeTrain', seed=0)
  126. res0 = ep.spiketrain_to_dataframe(obj)
  127. res1 = ep.spiketrain_to_dataframe(obj, child_first=True)
  128. res2 = ep.spiketrain_to_dataframe(obj, child_first=False)
  129. res3 = ep.spiketrain_to_dataframe(obj, parents=True)
  130. res4 = ep.spiketrain_to_dataframe(obj, parents=True,
  131. child_first=True)
  132. res5 = ep.spiketrain_to_dataframe(obj, parents=True,
  133. child_first=False)
  134. res6 = ep.spiketrain_to_dataframe(obj, parents=False)
  135. res7 = ep.spiketrain_to_dataframe(obj, parents=False, child_first=True)
  136. res8 = ep.spiketrain_to_dataframe(obj, parents=False,
  137. child_first=False)
  138. targvalues = pq.Quantity(obj.magnitude, units=obj.units)
  139. targvalues = targvalues.rescale('s').magnitude[np.newaxis].T
  140. targindex = np.arange(len(targvalues))
  141. attrs = ep._extract_neo_attrs_safe(obj, parents=True, child_first=True)
  142. keys, values = zip(*sorted(attrs.items()))
  143. values = _convert_levels(values)
  144. self.assertEqual(1, len(res0.columns))
  145. self.assertEqual(1, len(res1.columns))
  146. self.assertEqual(1, len(res2.columns))
  147. self.assertEqual(1, len(res3.columns))
  148. self.assertEqual(1, len(res4.columns))
  149. self.assertEqual(1, len(res5.columns))
  150. self.assertEqual(1, len(res6.columns))
  151. self.assertEqual(1, len(res7.columns))
  152. self.assertEqual(1, len(res8.columns))
  153. self.assertEqual(len(obj), len(res0.index))
  154. self.assertEqual(len(obj), len(res1.index))
  155. self.assertEqual(len(obj), len(res2.index))
  156. self.assertEqual(len(obj), len(res3.index))
  157. self.assertEqual(len(obj), len(res4.index))
  158. self.assertEqual(len(obj), len(res5.index))
  159. self.assertEqual(len(obj), len(res6.index))
  160. self.assertEqual(len(obj), len(res7.index))
  161. self.assertEqual(len(obj), len(res8.index))
  162. assert_array_equal(targvalues, res0.values)
  163. assert_array_equal(targvalues, res1.values)
  164. assert_array_equal(targvalues, res2.values)
  165. assert_array_equal(targvalues, res3.values)
  166. assert_array_equal(targvalues, res4.values)
  167. assert_array_equal(targvalues, res5.values)
  168. assert_array_equal(targvalues, res6.values)
  169. assert_array_equal(targvalues, res7.values)
  170. assert_array_equal(targvalues, res8.values)
  171. assert_array_equal(targindex, res0.index)
  172. assert_array_equal(targindex, res1.index)
  173. assert_array_equal(targindex, res2.index)
  174. assert_array_equal(targindex, res3.index)
  175. assert_array_equal(targindex, res4.index)
  176. assert_array_equal(targindex, res5.index)
  177. assert_array_equal(targindex, res6.index)
  178. assert_array_equal(targindex, res7.index)
  179. assert_array_equal(targindex, res8.index)
  180. self.assertEqual(['spike_number'], res0.index.names)
  181. self.assertEqual(['spike_number'], res1.index.names)
  182. self.assertEqual(['spike_number'], res2.index.names)
  183. self.assertEqual(['spike_number'], res3.index.names)
  184. self.assertEqual(['spike_number'], res4.index.names)
  185. self.assertEqual(['spike_number'], res5.index.names)
  186. self.assertEqual(['spike_number'], res6.index.names)
  187. self.assertEqual(['spike_number'], res7.index.names)
  188. self.assertEqual(['spike_number'], res8.index.names)
  189. self.assertEqual(keys, res0.columns.names)
  190. self.assertEqual(keys, res1.columns.names)
  191. self.assertEqual(keys, res2.columns.names)
  192. self.assertEqual(keys, res3.columns.names)
  193. self.assertEqual(keys, res4.columns.names)
  194. self.assertEqual(keys, res5.columns.names)
  195. self.assertEqual(keys, res6.columns.names)
  196. self.assertEqual(keys, res7.columns.names)
  197. self.assertEqual(keys, res8.columns.names)
  198. for value, level in zip(values, res0.columns.levels):
  199. assert_index_equal(value, level)
  200. for value, level in zip(values, res1.columns.levels):
  201. assert_index_equal(value, level)
  202. for value, level in zip(values, res2.columns.levels):
  203. assert_index_equal(value, level)
  204. for value, level in zip(values, res3.columns.levels):
  205. assert_index_equal(value, level)
  206. for value, level in zip(values, res4.columns.levels):
  207. assert_index_equal(value, level)
  208. for value, level in zip(values, res5.columns.levels):
  209. assert_index_equal(value, level)
  210. for value, level in zip(values, res6.columns.levels):
  211. assert_index_equal(value, level)
  212. for value, level in zip(values, res7.columns.levels):
  213. assert_index_equal(value, level)
  214. for value, level in zip(values, res8.columns.levels):
  215. assert_index_equal(value, level)
  216. def test__spiketrain_to_dataframe__noparents(self):
  217. blk = fake_neo('Block', seed=0)
  218. obj = blk.list_children_by_class('SpikeTrain')[0]
  219. res0 = ep.spiketrain_to_dataframe(obj, parents=False)
  220. res1 = ep.spiketrain_to_dataframe(obj, parents=False,
  221. child_first=True)
  222. res2 = ep.spiketrain_to_dataframe(obj, parents=False,
  223. child_first=False)
  224. targvalues = pq.Quantity(obj.magnitude, units=obj.units)
  225. targvalues = targvalues.rescale('s').magnitude[np.newaxis].T
  226. targindex = np.arange(len(targvalues))
  227. attrs = ep._extract_neo_attrs_safe(obj, parents=False,
  228. child_first=True)
  229. keys, values = zip(*sorted(attrs.items()))
  230. values = _convert_levels(values)
  231. self.assertEqual(1, len(res0.columns))
  232. self.assertEqual(1, len(res1.columns))
  233. self.assertEqual(1, len(res2.columns))
  234. self.assertEqual(len(obj), len(res0.index))
  235. self.assertEqual(len(obj), len(res1.index))
  236. self.assertEqual(len(obj), len(res2.index))
  237. assert_array_equal(targvalues, res0.values)
  238. assert_array_equal(targvalues, res1.values)
  239. assert_array_equal(targvalues, res2.values)
  240. assert_array_equal(targindex, res0.index)
  241. assert_array_equal(targindex, res1.index)
  242. assert_array_equal(targindex, res2.index)
  243. self.assertEqual(['spike_number'], res0.index.names)
  244. self.assertEqual(['spike_number'], res1.index.names)
  245. self.assertEqual(['spike_number'], res2.index.names)
  246. self.assertEqual(keys, res0.columns.names)
  247. self.assertEqual(keys, res1.columns.names)
  248. self.assertEqual(keys, res2.columns.names)
  249. for value, level in zip(values, res0.columns.levels):
  250. assert_index_equal(value, level)
  251. for value, level in zip(values, res1.columns.levels):
  252. assert_index_equal(value, level)
  253. for value, level in zip(values, res2.columns.levels):
  254. assert_index_equal(value, level)
  255. def test__spiketrain_to_dataframe__parents_childfirst(self):
  256. blk = fake_neo('Block', seed=0)
  257. obj = blk.list_children_by_class('SpikeTrain')[0]
  258. res0 = ep.spiketrain_to_dataframe(obj)
  259. res1 = ep.spiketrain_to_dataframe(obj, child_first=True)
  260. res2 = ep.spiketrain_to_dataframe(obj, parents=True)
  261. res3 = ep.spiketrain_to_dataframe(obj, parents=True, child_first=True)
  262. targvalues = pq.Quantity(obj.magnitude, units=obj.units)
  263. targvalues = targvalues.rescale('s').magnitude[np.newaxis].T
  264. targindex = np.arange(len(targvalues))
  265. attrs = ep._extract_neo_attrs_safe(obj, parents=True, child_first=True)
  266. keys, values = zip(*sorted(attrs.items()))
  267. values = _convert_levels(values)
  268. self.assertEqual(1, len(res0.columns))
  269. self.assertEqual(1, len(res1.columns))
  270. self.assertEqual(1, len(res2.columns))
  271. self.assertEqual(1, len(res3.columns))
  272. self.assertEqual(len(obj), len(res0.index))
  273. self.assertEqual(len(obj), len(res1.index))
  274. self.assertEqual(len(obj), len(res2.index))
  275. self.assertEqual(len(obj), len(res3.index))
  276. assert_array_equal(targvalues, res0.values)
  277. assert_array_equal(targvalues, res1.values)
  278. assert_array_equal(targvalues, res2.values)
  279. assert_array_equal(targvalues, res3.values)
  280. assert_array_equal(targindex, res0.index)
  281. assert_array_equal(targindex, res1.index)
  282. assert_array_equal(targindex, res2.index)
  283. assert_array_equal(targindex, res3.index)
  284. self.assertEqual(['spike_number'], res0.index.names)
  285. self.assertEqual(['spike_number'], res1.index.names)
  286. self.assertEqual(['spike_number'], res2.index.names)
  287. self.assertEqual(['spike_number'], res3.index.names)
  288. self.assertEqual(keys, res0.columns.names)
  289. self.assertEqual(keys, res1.columns.names)
  290. self.assertEqual(keys, res2.columns.names)
  291. self.assertEqual(keys, res3.columns.names)
  292. for value, level in zip(values, res0.columns.levels):
  293. assert_index_equal(value, level)
  294. for value, level in zip(values, res1.columns.levels):
  295. assert_index_equal(value, level)
  296. for value, level in zip(values, res2.columns.levels):
  297. assert_index_equal(value, level)
  298. for value, level in zip(values, res3.columns.levels):
  299. assert_index_equal(value, level)
  300. def test__spiketrain_to_dataframe__parents_parentfirst(self):
  301. blk = fake_neo('Block', seed=0)
  302. obj = blk.list_children_by_class('SpikeTrain')[0]
  303. res0 = ep.spiketrain_to_dataframe(obj, child_first=False)
  304. res1 = ep.spiketrain_to_dataframe(obj, parents=True, child_first=False)
  305. targvalues = pq.Quantity(obj.magnitude, units=obj.units)
  306. targvalues = targvalues.rescale('s').magnitude[np.newaxis].T
  307. targindex = np.arange(len(targvalues))
  308. attrs = ep._extract_neo_attrs_safe(obj, parents=True,
  309. child_first=False)
  310. keys, values = zip(*sorted(attrs.items()))
  311. values = _convert_levels(values)
  312. self.assertEqual(1, len(res0.columns))
  313. self.assertEqual(1, len(res1.columns))
  314. self.assertEqual(len(obj), len(res0.index))
  315. self.assertEqual(len(obj), len(res1.index))
  316. assert_array_equal(targvalues, res0.values)
  317. assert_array_equal(targvalues, res1.values)
  318. assert_array_equal(targindex, res0.index)
  319. assert_array_equal(targindex, res1.index)
  320. self.assertEqual(['spike_number'], res0.index.names)
  321. self.assertEqual(['spike_number'], res1.index.names)
  322. self.assertEqual(keys, res0.columns.names)
  323. self.assertEqual(keys, res1.columns.names)
  324. for value, level in zip(values, res0.columns.levels):
  325. assert_index_equal(value, level)
  326. for value, level in zip(values, res1.columns.levels):
  327. assert_index_equal(value, level)
  328. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  329. class EventToDataframeTestCase(unittest.TestCase):
  330. def test__event_to_dataframe__parents_empty(self):
  331. obj = fake_neo('Event', seed=42)
  332. res0 = ep.event_to_dataframe(obj)
  333. res1 = ep.event_to_dataframe(obj, child_first=True)
  334. res2 = ep.event_to_dataframe(obj, child_first=False)
  335. res3 = ep.event_to_dataframe(obj, parents=True)
  336. res4 = ep.event_to_dataframe(obj, parents=True, child_first=True)
  337. res5 = ep.event_to_dataframe(obj, parents=True, child_first=False)
  338. res6 = ep.event_to_dataframe(obj, parents=False)
  339. res7 = ep.event_to_dataframe(obj, parents=False, child_first=True)
  340. res8 = ep.event_to_dataframe(obj, parents=False, child_first=False)
  341. targvalues = obj.labels[:len(obj.times)][np.newaxis].T.astype('U')
  342. targindex = obj.times[:len(obj.labels)].rescale('s').magnitude
  343. attrs = ep._extract_neo_attrs_safe(obj, parents=True, child_first=True)
  344. keys, values = zip(*sorted(attrs.items()))
  345. values = _convert_levels(values)
  346. self.assertEqual(1, len(res0.columns))
  347. self.assertEqual(1, len(res1.columns))
  348. self.assertEqual(1, len(res2.columns))
  349. self.assertEqual(1, len(res3.columns))
  350. self.assertEqual(1, len(res4.columns))
  351. self.assertEqual(1, len(res5.columns))
  352. self.assertEqual(1, len(res6.columns))
  353. self.assertEqual(1, len(res7.columns))
  354. self.assertEqual(1, len(res8.columns))
  355. self.assertEqual(min(len(obj.times), len(obj.labels)),
  356. len(res0.index))
  357. self.assertEqual(min(len(obj.times), len(obj.labels)),
  358. len(res1.index))
  359. self.assertEqual(min(len(obj.times), len(obj.labels)),
  360. len(res2.index))
  361. self.assertEqual(min(len(obj.times), len(obj.labels)),
  362. len(res3.index))
  363. self.assertEqual(min(len(obj.times), len(obj.labels)),
  364. len(res4.index))
  365. self.assertEqual(min(len(obj.times), len(obj.labels)),
  366. len(res5.index))
  367. self.assertEqual(min(len(obj.times), len(obj.labels)),
  368. len(res6.index))
  369. self.assertEqual(min(len(obj.times), len(obj.labels)),
  370. len(res7.index))
  371. self.assertEqual(min(len(obj.times), len(obj.labels)),
  372. len(res8.index))
  373. assert_array_equal(targvalues, res0.values)
  374. assert_array_equal(targvalues, res1.values)
  375. assert_array_equal(targvalues, res2.values)
  376. assert_array_equal(targvalues, res3.values)
  377. assert_array_equal(targvalues, res4.values)
  378. assert_array_equal(targvalues, res5.values)
  379. assert_array_equal(targvalues, res6.values)
  380. assert_array_equal(targvalues, res7.values)
  381. assert_array_equal(targvalues, res8.values)
  382. assert_array_equal(targindex, res0.index)
  383. assert_array_equal(targindex, res1.index)
  384. assert_array_equal(targindex, res2.index)
  385. assert_array_equal(targindex, res3.index)
  386. assert_array_equal(targindex, res4.index)
  387. assert_array_equal(targindex, res5.index)
  388. assert_array_equal(targindex, res6.index)
  389. assert_array_equal(targindex, res7.index)
  390. assert_array_equal(targindex, res8.index)
  391. self.assertEqual(['times'], res0.index.names)
  392. self.assertEqual(['times'], res1.index.names)
  393. self.assertEqual(['times'], res2.index.names)
  394. self.assertEqual(['times'], res3.index.names)
  395. self.assertEqual(['times'], res4.index.names)
  396. self.assertEqual(['times'], res5.index.names)
  397. self.assertEqual(['times'], res6.index.names)
  398. self.assertEqual(['times'], res7.index.names)
  399. self.assertEqual(['times'], res8.index.names)
  400. self.assertEqual(keys, res0.columns.names)
  401. self.assertEqual(keys, res1.columns.names)
  402. self.assertEqual(keys, res2.columns.names)
  403. self.assertEqual(keys, res3.columns.names)
  404. self.assertEqual(keys, res4.columns.names)
  405. self.assertEqual(keys, res5.columns.names)
  406. self.assertEqual(keys, res6.columns.names)
  407. self.assertEqual(keys, res7.columns.names)
  408. self.assertEqual(keys, res8.columns.names)
  409. for value, level in zip(values, res0.columns.levels):
  410. assert_index_equal(value, level)
  411. for value, level in zip(values, res1.columns.levels):
  412. assert_index_equal(value, level)
  413. for value, level in zip(values, res2.columns.levels):
  414. assert_index_equal(value, level)
  415. for value, level in zip(values, res3.columns.levels):
  416. assert_index_equal(value, level)
  417. for value, level in zip(values, res4.columns.levels):
  418. assert_index_equal(value, level)
  419. for value, level in zip(values, res5.columns.levels):
  420. assert_index_equal(value, level)
  421. for value, level in zip(values, res6.columns.levels):
  422. assert_index_equal(value, level)
  423. for value, level in zip(values, res7.columns.levels):
  424. assert_index_equal(value, level)
  425. for value, level in zip(values, res8.columns.levels):
  426. assert_index_equal(value, level)
  427. def test__event_to_dataframe__noparents(self):
  428. blk = fake_neo('Block', seed=42)
  429. obj = blk.list_children_by_class('Event')[0]
  430. res0 = ep.event_to_dataframe(obj, parents=False)
  431. res1 = ep.event_to_dataframe(obj, parents=False, child_first=False)
  432. res2 = ep.event_to_dataframe(obj, parents=False, child_first=True)
  433. targvalues = obj.labels[:len(obj.times)][np.newaxis].T.astype('U')
  434. targindex = obj.times[:len(obj.labels)].rescale('s').magnitude
  435. attrs = ep._extract_neo_attrs_safe(obj, parents=False,
  436. child_first=True)
  437. keys, values = zip(*sorted(attrs.items()))
  438. values = _convert_levels(values)
  439. self.assertEqual(1, len(res0.columns))
  440. self.assertEqual(1, len(res1.columns))
  441. self.assertEqual(1, len(res2.columns))
  442. self.assertEqual(min(len(obj.times), len(obj.labels)),
  443. len(res0.index))
  444. self.assertEqual(min(len(obj.times), len(obj.labels)),
  445. len(res1.index))
  446. self.assertEqual(min(len(obj.times), len(obj.labels)),
  447. len(res2.index))
  448. assert_array_equal(targvalues, res0.values)
  449. assert_array_equal(targvalues, res1.values)
  450. assert_array_equal(targvalues, res2.values)
  451. assert_array_equal(targindex, res0.index)
  452. assert_array_equal(targindex, res1.index)
  453. assert_array_equal(targindex, res2.index)
  454. self.assertEqual(['times'], res0.index.names)
  455. self.assertEqual(['times'], res1.index.names)
  456. self.assertEqual(['times'], res2.index.names)
  457. self.assertEqual(keys, res0.columns.names)
  458. self.assertEqual(keys, res1.columns.names)
  459. self.assertEqual(keys, res2.columns.names)
  460. for value, level in zip(values, res0.columns.levels):
  461. assert_index_equal(value, level)
  462. for value, level in zip(values, res1.columns.levels):
  463. assert_index_equal(value, level)
  464. for value, level in zip(values, res2.columns.levels):
  465. assert_index_equal(value, level)
  466. def test__event_to_dataframe__parents_childfirst(self):
  467. blk = fake_neo('Block', seed=42)
  468. obj = blk.list_children_by_class('Event')[0]
  469. res0 = ep.event_to_dataframe(obj)
  470. res1 = ep.event_to_dataframe(obj, child_first=True)
  471. res2 = ep.event_to_dataframe(obj, parents=True)
  472. res3 = ep.event_to_dataframe(obj, parents=True, child_first=True)
  473. targvalues = obj.labels[:len(obj.times)][np.newaxis].T.astype('U')
  474. targindex = obj.times[:len(obj.labels)].rescale('s').magnitude
  475. attrs = ep._extract_neo_attrs_safe(obj, parents=True, child_first=True)
  476. keys, values = zip(*sorted(attrs.items()))
  477. values = _convert_levels(values)
  478. self.assertEqual(1, len(res0.columns))
  479. self.assertEqual(1, len(res1.columns))
  480. self.assertEqual(1, len(res2.columns))
  481. self.assertEqual(1, len(res3.columns))
  482. self.assertEqual(min(len(obj.times), len(obj.labels)),
  483. len(res0.index))
  484. self.assertEqual(min(len(obj.times), len(obj.labels)),
  485. len(res1.index))
  486. self.assertEqual(min(len(obj.times), len(obj.labels)),
  487. len(res2.index))
  488. self.assertEqual(min(len(obj.times), len(obj.labels)),
  489. len(res3.index))
  490. assert_array_equal(targvalues, res0.values)
  491. assert_array_equal(targvalues, res1.values)
  492. assert_array_equal(targvalues, res2.values)
  493. assert_array_equal(targvalues, res3.values)
  494. assert_array_equal(targindex, res0.index)
  495. assert_array_equal(targindex, res1.index)
  496. assert_array_equal(targindex, res2.index)
  497. assert_array_equal(targindex, res3.index)
  498. self.assertEqual(['times'], res0.index.names)
  499. self.assertEqual(['times'], res1.index.names)
  500. self.assertEqual(['times'], res2.index.names)
  501. self.assertEqual(['times'], res3.index.names)
  502. self.assertEqual(keys, res0.columns.names)
  503. self.assertEqual(keys, res1.columns.names)
  504. self.assertEqual(keys, res2.columns.names)
  505. self.assertEqual(keys, res3.columns.names)
  506. for value, level in zip(values, res0.columns.levels):
  507. assert_index_equal(value, level)
  508. for value, level in zip(values, res1.columns.levels):
  509. assert_index_equal(value, level)
  510. for value, level in zip(values, res2.columns.levels):
  511. assert_index_equal(value, level)
  512. for value, level in zip(values, res3.columns.levels):
  513. assert_index_equal(value, level)
  514. def test__event_to_dataframe__parents_parentfirst(self):
  515. blk = fake_neo('Block', seed=42)
  516. obj = blk.list_children_by_class('Event')[0]
  517. res0 = ep.event_to_dataframe(obj, child_first=False)
  518. res1 = ep.event_to_dataframe(obj, parents=True, child_first=False)
  519. targvalues = obj.labels[:len(obj.times)][np.newaxis].T.astype('U')
  520. targindex = obj.times[:len(obj.labels)].rescale('s').magnitude
  521. attrs = ep._extract_neo_attrs_safe(obj, parents=True,
  522. child_first=False)
  523. keys, values = zip(*sorted(attrs.items()))
  524. values = _convert_levels(values)
  525. self.assertEqual(1, len(res0.columns))
  526. self.assertEqual(1, len(res1.columns))
  527. self.assertEqual(min(len(obj.times), len(obj.labels)),
  528. len(res0.index))
  529. self.assertEqual(min(len(obj.times), len(obj.labels)),
  530. len(res1.index))
  531. assert_array_equal(targvalues, res0.values)
  532. assert_array_equal(targvalues, res1.values)
  533. assert_array_equal(targindex, res0.index)
  534. assert_array_equal(targindex, res1.index)
  535. self.assertEqual(['times'], res0.index.names)
  536. self.assertEqual(['times'], res1.index.names)
  537. self.assertEqual(keys, res0.columns.names)
  538. self.assertEqual(keys, res1.columns.names)
  539. for value, level in zip(values, res0.columns.levels):
  540. assert_index_equal(value, level)
  541. for value, level in zip(values, res1.columns.levels):
  542. assert_index_equal(value, level)
  543. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  544. class EpochToDataframeTestCase(unittest.TestCase):
  545. def test__epoch_to_dataframe__parents_empty(self):
  546. obj = fake_neo('Epoch', seed=42)
  547. res0 = ep.epoch_to_dataframe(obj)
  548. res1 = ep.epoch_to_dataframe(obj, child_first=True)
  549. res2 = ep.epoch_to_dataframe(obj, child_first=False)
  550. res3 = ep.epoch_to_dataframe(obj, parents=True)
  551. res4 = ep.epoch_to_dataframe(obj, parents=True, child_first=True)
  552. res5 = ep.epoch_to_dataframe(obj, parents=True, child_first=False)
  553. res6 = ep.epoch_to_dataframe(obj, parents=False)
  554. res7 = ep.epoch_to_dataframe(obj, parents=False, child_first=True)
  555. res8 = ep.epoch_to_dataframe(obj, parents=False, child_first=False)
  556. minlen = min([len(obj.times), len(obj.durations), len(obj.labels)])
  557. targvalues = obj.labels[:minlen][np.newaxis].T.astype('U')
  558. targindex = np.vstack([obj.durations[:minlen].rescale('s').magnitude,
  559. obj.times[:minlen].rescale('s').magnitude])
  560. targvalues = targvalues[targindex.argsort()[0], :]
  561. targindex.sort()
  562. attrs = ep._extract_neo_attrs_safe(obj, parents=True,
  563. child_first=True)
  564. keys, values = zip(*sorted(attrs.items()))
  565. values = _convert_levels(values)
  566. self.assertEqual(1, len(res0.columns))
  567. self.assertEqual(1, len(res1.columns))
  568. self.assertEqual(1, len(res2.columns))
  569. self.assertEqual(1, len(res3.columns))
  570. self.assertEqual(1, len(res4.columns))
  571. self.assertEqual(1, len(res5.columns))
  572. self.assertEqual(1, len(res6.columns))
  573. self.assertEqual(1, len(res7.columns))
  574. self.assertEqual(1, len(res8.columns))
  575. self.assertEqual(min(len(obj.times), len(obj.durations),
  576. len(obj.labels)),
  577. len(res0.index))
  578. self.assertEqual(min(len(obj.times), len(obj.durations),
  579. len(obj.labels)),
  580. len(res1.index))
  581. self.assertEqual(min(len(obj.times), len(obj.durations),
  582. len(obj.labels)),
  583. len(res2.index))
  584. self.assertEqual(min(len(obj.times), len(obj.durations),
  585. len(obj.labels)),
  586. len(res3.index))
  587. self.assertEqual(min(len(obj.times), len(obj.durations),
  588. len(obj.labels)),
  589. len(res4.index))
  590. self.assertEqual(min(len(obj.times), len(obj.durations),
  591. len(obj.labels)),
  592. len(res5.index))
  593. self.assertEqual(min(len(obj.times), len(obj.durations),
  594. len(obj.labels)),
  595. len(res6.index))
  596. self.assertEqual(min(len(obj.times), len(obj.durations),
  597. len(obj.labels)),
  598. len(res7.index))
  599. self.assertEqual(min(len(obj.times), len(obj.durations),
  600. len(obj.labels)),
  601. len(res8.index))
  602. assert_array_equal(targvalues, res0.values)
  603. assert_array_equal(targvalues, res1.values)
  604. assert_array_equal(targvalues, res2.values)
  605. assert_array_equal(targvalues, res3.values)
  606. assert_array_equal(targvalues, res4.values)
  607. assert_array_equal(targvalues, res5.values)
  608. assert_array_equal(targvalues, res6.values)
  609. assert_array_equal(targvalues, res7.values)
  610. assert_array_equal(targvalues, res8.values)
  611. self.assertEqual(keys, res0.columns.names)
  612. self.assertEqual(keys, res1.columns.names)
  613. self.assertEqual(keys, res2.columns.names)
  614. self.assertEqual(keys, res3.columns.names)
  615. self.assertEqual(keys, res4.columns.names)
  616. self.assertEqual(keys, res5.columns.names)
  617. self.assertEqual(keys, res6.columns.names)
  618. self.assertEqual(keys, res7.columns.names)
  619. self.assertEqual(keys, res8.columns.names)
  620. self.assertEqual([u'durations', u'times'], res0.index.names)
  621. self.assertEqual([u'durations', u'times'], res1.index.names)
  622. self.assertEqual([u'durations', u'times'], res2.index.names)
  623. self.assertEqual([u'durations', u'times'], res3.index.names)
  624. self.assertEqual([u'durations', u'times'], res4.index.names)
  625. self.assertEqual([u'durations', u'times'], res5.index.names)
  626. self.assertEqual([u'durations', u'times'], res6.index.names)
  627. self.assertEqual([u'durations', u'times'], res7.index.names)
  628. self.assertEqual([u'durations', u'times'], res8.index.names)
  629. self.assertEqual(2, len(res0.index.levels))
  630. self.assertEqual(2, len(res1.index.levels))
  631. self.assertEqual(2, len(res2.index.levels))
  632. self.assertEqual(2, len(res3.index.levels))
  633. self.assertEqual(2, len(res4.index.levels))
  634. self.assertEqual(2, len(res5.index.levels))
  635. self.assertEqual(2, len(res6.index.levels))
  636. self.assertEqual(2, len(res7.index.levels))
  637. self.assertEqual(2, len(res8.index.levels))
  638. assert_array_equal(targindex, res0.index.levels)
  639. assert_array_equal(targindex, res1.index.levels)
  640. assert_array_equal(targindex, res2.index.levels)
  641. assert_array_equal(targindex, res3.index.levels)
  642. assert_array_equal(targindex, res4.index.levels)
  643. assert_array_equal(targindex, res5.index.levels)
  644. assert_array_equal(targindex, res6.index.levels)
  645. assert_array_equal(targindex, res7.index.levels)
  646. assert_array_equal(targindex, res8.index.levels)
  647. for value, level in zip(values, res0.columns.levels):
  648. assert_index_equal(value, level)
  649. for value, level in zip(values, res1.columns.levels):
  650. assert_index_equal(value, level)
  651. for value, level in zip(values, res2.columns.levels):
  652. assert_index_equal(value, level)
  653. for value, level in zip(values, res3.columns.levels):
  654. assert_index_equal(value, level)
  655. for value, level in zip(values, res4.columns.levels):
  656. assert_index_equal(value, level)
  657. for value, level in zip(values, res5.columns.levels):
  658. assert_index_equal(value, level)
  659. for value, level in zip(values, res6.columns.levels):
  660. assert_index_equal(value, level)
  661. for value, level in zip(values, res7.columns.levels):
  662. assert_index_equal(value, level)
  663. for value, level in zip(values, res8.columns.levels):
  664. assert_index_equal(value, level)
  665. def test__epoch_to_dataframe__noparents(self):
  666. blk = fake_neo('Block', seed=42)
  667. obj = blk.list_children_by_class('Epoch')[0]
  668. res0 = ep.epoch_to_dataframe(obj, parents=False)
  669. res1 = ep.epoch_to_dataframe(obj, parents=False, child_first=True)
  670. res2 = ep.epoch_to_dataframe(obj, parents=False, child_first=False)
  671. minlen = min([len(obj.times), len(obj.durations), len(obj.labels)])
  672. targvalues = obj.labels[:minlen][np.newaxis].T.astype('U')
  673. targindex = np.vstack([obj.durations[:minlen].rescale('s').magnitude,
  674. obj.times[:minlen].rescale('s').magnitude])
  675. targvalues = targvalues[targindex.argsort()[0], :]
  676. targindex.sort()
  677. attrs = ep._extract_neo_attrs_safe(obj, parents=False,
  678. child_first=True)
  679. keys, values = zip(*sorted(attrs.items()))
  680. values = _convert_levels(values)
  681. self.assertEqual(1, len(res0.columns))
  682. self.assertEqual(1, len(res1.columns))
  683. self.assertEqual(1, len(res2.columns))
  684. self.assertEqual(min(len(obj.times), len(obj.durations),
  685. len(obj.labels)),
  686. len(res0.index))
  687. self.assertEqual(min(len(obj.times), len(obj.durations),
  688. len(obj.labels)),
  689. len(res1.index))
  690. self.assertEqual(min(len(obj.times), len(obj.durations),
  691. len(obj.labels)),
  692. len(res2.index))
  693. assert_array_equal(targvalues, res0.values)
  694. assert_array_equal(targvalues, res1.values)
  695. assert_array_equal(targvalues, res2.values)
  696. self.assertEqual(keys, res0.columns.names)
  697. self.assertEqual(keys, res1.columns.names)
  698. self.assertEqual(keys, res2.columns.names)
  699. self.assertEqual([u'durations', u'times'], res0.index.names)
  700. self.assertEqual([u'durations', u'times'], res1.index.names)
  701. self.assertEqual([u'durations', u'times'], res2.index.names)
  702. self.assertEqual(2, len(res0.index.levels))
  703. self.assertEqual(2, len(res1.index.levels))
  704. self.assertEqual(2, len(res2.index.levels))
  705. assert_array_equal(targindex, res0.index.levels)
  706. assert_array_equal(targindex, res1.index.levels)
  707. assert_array_equal(targindex, res2.index.levels)
  708. for value, level in zip(values, res0.columns.levels):
  709. assert_index_equal(value, level)
  710. for value, level in zip(values, res1.columns.levels):
  711. assert_index_equal(value, level)
  712. for value, level in zip(values, res2.columns.levels):
  713. assert_index_equal(value, level)
  714. def test__epoch_to_dataframe__parents_childfirst(self):
  715. blk = fake_neo('Block', seed=42)
  716. obj = blk.list_children_by_class('Epoch')[0]
  717. res0 = ep.epoch_to_dataframe(obj)
  718. res1 = ep.epoch_to_dataframe(obj, child_first=True)
  719. res2 = ep.epoch_to_dataframe(obj, parents=True)
  720. res3 = ep.epoch_to_dataframe(obj, parents=True, child_first=True)
  721. minlen = min([len(obj.times), len(obj.durations), len(obj.labels)])
  722. targvalues = obj.labels[:minlen][np.newaxis].T.astype('U')
  723. targindex = np.vstack([obj.durations[:minlen].rescale('s').magnitude,
  724. obj.times[:minlen].rescale('s').magnitude])
  725. targvalues = targvalues[targindex.argsort()[0], :]
  726. targindex.sort()
  727. attrs = ep._extract_neo_attrs_safe(obj, parents=True, child_first=True)
  728. keys, values = zip(*sorted(attrs.items()))
  729. values = _convert_levels(values)
  730. self.assertEqual(1, len(res0.columns))
  731. self.assertEqual(1, len(res1.columns))
  732. self.assertEqual(1, len(res2.columns))
  733. self.assertEqual(1, len(res3.columns))
  734. self.assertEqual(min(len(obj.times), len(obj.durations),
  735. len(obj.labels)),
  736. len(res0.index))
  737. self.assertEqual(min(len(obj.times), len(obj.durations),
  738. len(obj.labels)),
  739. len(res1.index))
  740. self.assertEqual(min(len(obj.times), len(obj.durations),
  741. len(obj.labels)),
  742. len(res2.index))
  743. self.assertEqual(min(len(obj.times), len(obj.durations),
  744. len(obj.labels)),
  745. len(res3.index))
  746. assert_array_equal(targvalues, res0.values)
  747. assert_array_equal(targvalues, res1.values)
  748. assert_array_equal(targvalues, res2.values)
  749. assert_array_equal(targvalues, res3.values)
  750. self.assertEqual(keys, res0.columns.names)
  751. self.assertEqual(keys, res1.columns.names)
  752. self.assertEqual(keys, res2.columns.names)
  753. self.assertEqual(keys, res3.columns.names)
  754. self.assertEqual([u'durations', u'times'], res0.index.names)
  755. self.assertEqual([u'durations', u'times'], res1.index.names)
  756. self.assertEqual([u'durations', u'times'], res2.index.names)
  757. self.assertEqual([u'durations', u'times'], res3.index.names)
  758. self.assertEqual(2, len(res0.index.levels))
  759. self.assertEqual(2, len(res1.index.levels))
  760. self.assertEqual(2, len(res2.index.levels))
  761. self.assertEqual(2, len(res3.index.levels))
  762. assert_array_equal(targindex, res0.index.levels)
  763. assert_array_equal(targindex, res1.index.levels)
  764. assert_array_equal(targindex, res2.index.levels)
  765. assert_array_equal(targindex, res3.index.levels)
  766. for value, level in zip(values, res0.columns.levels):
  767. assert_index_equal(value, level)
  768. for value, level in zip(values, res1.columns.levels):
  769. assert_index_equal(value, level)
  770. for value, level in zip(values, res2.columns.levels):
  771. assert_index_equal(value, level)
  772. for value, level in zip(values, res3.columns.levels):
  773. assert_index_equal(value, level)
  774. def test__epoch_to_dataframe__parents_parentfirst(self):
  775. blk = fake_neo('Block', seed=42)
  776. obj = blk.list_children_by_class('Epoch')[0]
  777. res0 = ep.epoch_to_dataframe(obj, child_first=False)
  778. res1 = ep.epoch_to_dataframe(obj, parents=True, child_first=False)
  779. minlen = min([len(obj.times), len(obj.durations), len(obj.labels)])
  780. targvalues = obj.labels[:minlen][np.newaxis].T.astype('U')
  781. targindex = np.vstack([obj.durations[:minlen].rescale('s').magnitude,
  782. obj.times[:minlen].rescale('s').magnitude])
  783. targvalues = targvalues[targindex.argsort()[0], :]
  784. targindex.sort()
  785. attrs = ep._extract_neo_attrs_safe(obj, parents=True,
  786. child_first=False)
  787. keys, values = zip(*sorted(attrs.items()))
  788. values = _convert_levels(values)
  789. self.assertEqual(1, len(res0.columns))
  790. self.assertEqual(1, len(res1.columns))
  791. self.assertEqual(min(len(obj.times), len(obj.durations),
  792. len(obj.labels)),
  793. len(res0.index))
  794. self.assertEqual(min(len(obj.times), len(obj.durations),
  795. len(obj.labels)),
  796. len(res1.index))
  797. assert_array_equal(targvalues, res0.values)
  798. assert_array_equal(targvalues, res1.values)
  799. self.assertEqual(keys, res0.columns.names)
  800. self.assertEqual(keys, res1.columns.names)
  801. self.assertEqual([u'durations', u'times'], res0.index.names)
  802. self.assertEqual([u'durations', u'times'], res1.index.names)
  803. self.assertEqual(2, len(res0.index.levels))
  804. self.assertEqual(2, len(res1.index.levels))
  805. assert_array_equal(targindex, res0.index.levels)
  806. assert_array_equal(targindex, res1.index.levels)
  807. for value, level in zip(values, res0.columns.levels):
  808. assert_index_equal(value, level)
  809. for value, level in zip(values, res1.columns.levels):
  810. assert_index_equal(value, level)
  811. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  812. class MultiSpiketrainsToDataframeTestCase(unittest.TestCase):
  813. def setUp(self):
  814. if hasattr(self, 'assertItemsEqual'):
  815. self.assertCountEqual = self.assertItemsEqual
  816. def test__multi_spiketrains_to_dataframe__single(self):
  817. obj = fake_neo('SpikeTrain', seed=0, n=5)
  818. res0 = ep.multi_spiketrains_to_dataframe(obj)
  819. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False)
  820. res2 = ep.multi_spiketrains_to_dataframe(obj, parents=True)
  821. res3 = ep.multi_spiketrains_to_dataframe(obj, child_first=True)
  822. res4 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  823. child_first=True)
  824. res5 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  825. child_first=True)
  826. res6 = ep.multi_spiketrains_to_dataframe(obj, child_first=False)
  827. res7 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  828. child_first=False)
  829. res8 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  830. child_first=False)
  831. targ = ep.spiketrain_to_dataframe(obj)
  832. keys = ep._extract_neo_attrs_safe(obj, parents=True,
  833. child_first=True).keys()
  834. keys = list(keys)
  835. targwidth = 1
  836. targlen = len(obj)
  837. self.assertEqual(targwidth, len(targ.columns))
  838. self.assertEqual(targwidth, len(res0.columns))
  839. self.assertEqual(targwidth, len(res1.columns))
  840. self.assertEqual(targwidth, len(res2.columns))
  841. self.assertEqual(targwidth, len(res3.columns))
  842. self.assertEqual(targwidth, len(res4.columns))
  843. self.assertEqual(targwidth, len(res5.columns))
  844. self.assertEqual(targwidth, len(res6.columns))
  845. self.assertEqual(targwidth, len(res7.columns))
  846. self.assertEqual(targwidth, len(res8.columns))
  847. self.assertEqual(targlen, len(targ.index))
  848. self.assertEqual(targlen, len(res0.index))
  849. self.assertEqual(targlen, len(res1.index))
  850. self.assertEqual(targlen, len(res2.index))
  851. self.assertEqual(targlen, len(res3.index))
  852. self.assertEqual(targlen, len(res4.index))
  853. self.assertEqual(targlen, len(res5.index))
  854. self.assertEqual(targlen, len(res6.index))
  855. self.assertEqual(targlen, len(res7.index))
  856. self.assertEqual(targlen, len(res8.index))
  857. self.assertCountEqual(keys, targ.columns.names)
  858. self.assertCountEqual(keys, res0.columns.names)
  859. self.assertCountEqual(keys, res1.columns.names)
  860. self.assertCountEqual(keys, res2.columns.names)
  861. self.assertCountEqual(keys, res3.columns.names)
  862. self.assertCountEqual(keys, res4.columns.names)
  863. self.assertCountEqual(keys, res5.columns.names)
  864. self.assertCountEqual(keys, res6.columns.names)
  865. self.assertCountEqual(keys, res7.columns.names)
  866. self.assertCountEqual(keys, res8.columns.names)
  867. assert_array_equal(targ.values, res0.values)
  868. assert_array_equal(targ.values, res1.values)
  869. assert_array_equal(targ.values, res2.values)
  870. assert_array_equal(targ.values, res3.values)
  871. assert_array_equal(targ.values, res4.values)
  872. assert_array_equal(targ.values, res5.values)
  873. assert_array_equal(targ.values, res6.values)
  874. assert_array_equal(targ.values, res7.values)
  875. assert_array_equal(targ.values, res8.values)
  876. assert_frame_equal(targ, res0)
  877. assert_frame_equal(targ, res0)
  878. assert_frame_equal(targ, res1)
  879. assert_frame_equal(targ, res2)
  880. assert_frame_equal(targ, res3)
  881. assert_frame_equal(targ, res4)
  882. assert_frame_equal(targ, res5)
  883. assert_frame_equal(targ, res6)
  884. assert_frame_equal(targ, res7)
  885. assert_frame_equal(targ, res8)
  886. def test__multi_spiketrains_to_dataframe__unit_default(self):
  887. obj = fake_neo('Unit', seed=0, n=5)
  888. res0 = ep.multi_spiketrains_to_dataframe(obj)
  889. objs = obj.spiketrains
  890. targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs]
  891. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  892. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  893. child_first=True).keys()
  894. keys = list(keys)
  895. targwidth = len(objs)
  896. targlen = max(len(iobj) for iobj in objs)
  897. self.assertGreater(len(objs), 0)
  898. self.assertEqual(targwidth, len(targ.columns))
  899. self.assertEqual(targwidth, len(res0.columns))
  900. self.assertEqual(targlen, len(targ.index))
  901. self.assertEqual(targlen, len(res0.index))
  902. self.assertCountEqual(keys, targ.columns.names)
  903. self.assertCountEqual(keys, res0.columns.names)
  904. assert_array_equal(targ.values, res0.values)
  905. assert_frame_equal(targ, res0)
  906. def test__multi_spiketrains_to_dataframe__segment_default(self):
  907. obj = fake_neo('Segment', seed=0, n=5)
  908. res0 = ep.multi_spiketrains_to_dataframe(obj)
  909. objs = obj.spiketrains
  910. targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs]
  911. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  912. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  913. child_first=True).keys()
  914. keys = list(keys)
  915. targwidth = len(objs)
  916. targlen = max(len(iobj) for iobj in objs)
  917. self.assertGreater(len(objs), 0)
  918. self.assertEqual(targwidth, len(targ.columns))
  919. self.assertEqual(targwidth, len(res0.columns))
  920. self.assertEqual(targlen, len(targ.index))
  921. self.assertEqual(targlen, len(res0.index))
  922. self.assertCountEqual(keys, targ.columns.names)
  923. self.assertCountEqual(keys, res0.columns.names)
  924. assert_array_equal(targ.values, res0.values)
  925. assert_frame_equal(targ, res0)
  926. def test__multi_spiketrains_to_dataframe__block_noparents(self):
  927. obj = fake_neo('Block', seed=0, n=3)
  928. res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False)
  929. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  930. child_first=True)
  931. res2 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  932. child_first=False)
  933. objs = obj.list_children_by_class('SpikeTrain')
  934. targ = [ep.spiketrain_to_dataframe(iobj,
  935. parents=False, child_first=True)
  936. for iobj in objs]
  937. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  938. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  939. child_first=True).keys()
  940. keys = list(keys)
  941. targwidth = len(objs)
  942. targlen = max(len(iobj) for iobj in objs)
  943. self.assertGreater(len(objs), 0)
  944. self.assertEqual(targwidth, len(targ.columns))
  945. self.assertEqual(targwidth, len(res0.columns))
  946. self.assertEqual(targwidth, len(res1.columns))
  947. self.assertEqual(targwidth, len(res2.columns))
  948. self.assertEqual(targlen, len(targ.index))
  949. self.assertEqual(targlen, len(res0.index))
  950. self.assertEqual(targlen, len(res1.index))
  951. self.assertEqual(targlen, len(res2.index))
  952. self.assertCountEqual(keys, targ.columns.names)
  953. self.assertCountEqual(keys, res0.columns.names)
  954. self.assertCountEqual(keys, res1.columns.names)
  955. self.assertCountEqual(keys, res2.columns.names)
  956. assert_array_equal(targ.values, res0.values)
  957. assert_array_equal(targ.values, res1.values)
  958. assert_array_equal(targ.values, res2.values)
  959. assert_frame_equal(targ, res0)
  960. assert_frame_equal(targ, res1)
  961. assert_frame_equal(targ, res2)
  962. def test__multi_spiketrains_to_dataframe__block_parents_childfirst(self):
  963. obj = fake_neo('Block', seed=0, n=3)
  964. res0 = ep.multi_spiketrains_to_dataframe(obj)
  965. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True)
  966. res2 = ep.multi_spiketrains_to_dataframe(obj, child_first=True)
  967. res3 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  968. child_first=True)
  969. objs = obj.list_children_by_class('SpikeTrain')
  970. targ = [ep.spiketrain_to_dataframe(iobj,
  971. parents=True, child_first=True)
  972. for iobj in objs]
  973. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  974. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  975. child_first=True).keys()
  976. keys = list(keys)
  977. targwidth = len(objs)
  978. targlen = max(len(iobj) for iobj in objs)
  979. self.assertGreater(len(objs), 0)
  980. self.assertEqual(targwidth, len(targ.columns))
  981. self.assertEqual(targwidth, len(res0.columns))
  982. self.assertEqual(targwidth, len(res1.columns))
  983. self.assertEqual(targwidth, len(res2.columns))
  984. self.assertEqual(targwidth, len(res3.columns))
  985. self.assertEqual(targlen, len(targ.index))
  986. self.assertEqual(targlen, len(res0.index))
  987. self.assertEqual(targlen, len(res1.index))
  988. self.assertEqual(targlen, len(res2.index))
  989. self.assertEqual(targlen, len(res3.index))
  990. self.assertCountEqual(keys, targ.columns.names)
  991. self.assertCountEqual(keys, res0.columns.names)
  992. self.assertCountEqual(keys, res1.columns.names)
  993. self.assertCountEqual(keys, res2.columns.names)
  994. self.assertCountEqual(keys, res3.columns.names)
  995. assert_array_equal(targ.values, res0.values)
  996. assert_array_equal(targ.values, res1.values)
  997. assert_array_equal(targ.values, res2.values)
  998. assert_array_equal(targ.values, res3.values)
  999. assert_frame_equal(targ, res0)
  1000. assert_frame_equal(targ, res1)
  1001. assert_frame_equal(targ, res2)
  1002. assert_frame_equal(targ, res3)
  1003. def test__multi_spiketrains_to_dataframe__block_parents_parentfirst(self):
  1004. obj = fake_neo('Block', seed=0, n=3)
  1005. res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False)
  1006. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  1007. child_first=False)
  1008. objs = obj.list_children_by_class('SpikeTrain')
  1009. targ = [ep.spiketrain_to_dataframe(iobj,
  1010. parents=True, child_first=False)
  1011. for iobj in objs]
  1012. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1013. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1014. child_first=False).keys()
  1015. keys = list(keys)
  1016. targwidth = len(objs)
  1017. targlen = max(len(iobj) for iobj in objs)
  1018. self.assertGreater(len(objs), 0)
  1019. self.assertEqual(targwidth, len(targ.columns))
  1020. self.assertEqual(targwidth, len(res0.columns))
  1021. self.assertEqual(targwidth, len(res1.columns))
  1022. self.assertEqual(targlen, len(targ.index))
  1023. self.assertEqual(targlen, len(res0.index))
  1024. self.assertEqual(targlen, len(res1.index))
  1025. self.assertCountEqual(keys, targ.columns.names)
  1026. self.assertCountEqual(keys, res0.columns.names)
  1027. self.assertCountEqual(keys, res1.columns.names)
  1028. assert_array_equal(targ.values, res0.values)
  1029. assert_array_equal(targ.values, res1.values)
  1030. assert_frame_equal(targ, res0)
  1031. assert_frame_equal(targ, res1)
  1032. def test__multi_spiketrains_to_dataframe__list_noparents(self):
  1033. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1034. res0 = ep.multi_spiketrains_to_dataframe(obj, parents=False)
  1035. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  1036. child_first=True)
  1037. res2 = ep.multi_spiketrains_to_dataframe(obj, parents=False,
  1038. child_first=False)
  1039. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in obj)
  1040. objs = list(chain.from_iterable(objs))
  1041. targ = [ep.spiketrain_to_dataframe(iobj,
  1042. parents=False, child_first=True)
  1043. for iobj in objs]
  1044. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1045. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  1046. child_first=True).keys()
  1047. keys = list(keys)
  1048. targwidth = len(objs)
  1049. targlen = max(len(iobj) for iobj in objs)
  1050. self.assertGreater(len(objs), 0)
  1051. self.assertEqual(targwidth, len(targ.columns))
  1052. self.assertEqual(targwidth, len(res0.columns))
  1053. self.assertEqual(targwidth, len(res1.columns))
  1054. self.assertEqual(targwidth, len(res2.columns))
  1055. self.assertEqual(targlen, len(targ.index))
  1056. self.assertEqual(targlen, len(res0.index))
  1057. self.assertEqual(targlen, len(res1.index))
  1058. self.assertEqual(targlen, len(res2.index))
  1059. self.assertCountEqual(keys, targ.columns.names)
  1060. self.assertCountEqual(keys, res0.columns.names)
  1061. self.assertCountEqual(keys, res1.columns.names)
  1062. self.assertCountEqual(keys, res2.columns.names)
  1063. assert_array_equal(targ.values, res0.values)
  1064. assert_array_equal(targ.values, res1.values)
  1065. assert_array_equal(targ.values, res2.values)
  1066. assert_frame_equal(targ, res0)
  1067. assert_frame_equal(targ, res1)
  1068. assert_frame_equal(targ, res2)
  1069. def test__multi_spiketrains_to_dataframe__list_parents_childfirst(self):
  1070. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1071. res0 = ep.multi_spiketrains_to_dataframe(obj)
  1072. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True)
  1073. res2 = ep.multi_spiketrains_to_dataframe(obj, child_first=True)
  1074. res3 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  1075. child_first=True)
  1076. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in obj)
  1077. objs = list(chain.from_iterable(objs))
  1078. targ = [ep.spiketrain_to_dataframe(iobj,
  1079. parents=True, child_first=True)
  1080. for iobj in objs]
  1081. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1082. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1083. child_first=True).keys()
  1084. keys = list(keys)
  1085. targwidth = len(objs)
  1086. targlen = max(len(iobj) for iobj in objs)
  1087. self.assertGreater(len(objs), 0)
  1088. self.assertEqual(targwidth, len(targ.columns))
  1089. self.assertEqual(targwidth, len(res0.columns))
  1090. self.assertEqual(targwidth, len(res1.columns))
  1091. self.assertEqual(targwidth, len(res2.columns))
  1092. self.assertEqual(targwidth, len(res3.columns))
  1093. self.assertEqual(targlen, len(targ.index))
  1094. self.assertEqual(targlen, len(res0.index))
  1095. self.assertEqual(targlen, len(res1.index))
  1096. self.assertEqual(targlen, len(res2.index))
  1097. self.assertEqual(targlen, len(res3.index))
  1098. self.assertCountEqual(keys, targ.columns.names)
  1099. self.assertCountEqual(keys, res0.columns.names)
  1100. self.assertCountEqual(keys, res1.columns.names)
  1101. self.assertCountEqual(keys, res2.columns.names)
  1102. self.assertCountEqual(keys, res3.columns.names)
  1103. assert_array_equal(targ.values, res0.values)
  1104. assert_array_equal(targ.values, res1.values)
  1105. assert_array_equal(targ.values, res2.values)
  1106. assert_array_equal(targ.values, res3.values)
  1107. assert_frame_equal(targ, res0)
  1108. assert_frame_equal(targ, res1)
  1109. assert_frame_equal(targ, res2)
  1110. assert_frame_equal(targ, res3)
  1111. def test__multi_spiketrains_to_dataframe__list_parents_parentfirst(self):
  1112. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1113. res0 = ep.multi_spiketrains_to_dataframe(obj, child_first=False)
  1114. res1 = ep.multi_spiketrains_to_dataframe(obj, parents=True,
  1115. child_first=False)
  1116. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in obj)
  1117. objs = list(chain.from_iterable(objs))
  1118. targ = [ep.spiketrain_to_dataframe(iobj,
  1119. parents=True, child_first=False)
  1120. for iobj in objs]
  1121. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1122. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1123. child_first=False).keys()
  1124. keys = list(keys)
  1125. targwidth = len(objs)
  1126. targlen = max(len(iobj) for iobj in objs)
  1127. self.assertGreater(len(objs), 0)
  1128. self.assertEqual(targwidth, len(targ.columns))
  1129. self.assertEqual(targwidth, len(res0.columns))
  1130. self.assertEqual(targwidth, len(res1.columns))
  1131. self.assertEqual(targlen, len(targ.index))
  1132. self.assertEqual(targlen, len(res0.index))
  1133. self.assertEqual(targlen, len(res1.index))
  1134. self.assertCountEqual(keys, targ.columns.names)
  1135. self.assertCountEqual(keys, res0.columns.names)
  1136. self.assertCountEqual(keys, res1.columns.names)
  1137. assert_array_equal(targ.values, res0.values)
  1138. assert_array_equal(targ.values, res1.values)
  1139. assert_frame_equal(targ, res0)
  1140. assert_frame_equal(targ, res1)
  1141. def test__multi_spiketrains_to_dataframe__tuple_default(self):
  1142. obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3))
  1143. res0 = ep.multi_spiketrains_to_dataframe(obj)
  1144. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in obj)
  1145. objs = list(chain.from_iterable(objs))
  1146. targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs]
  1147. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1148. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1149. child_first=True).keys()
  1150. keys = list(keys)
  1151. targwidth = len(objs)
  1152. targlen = max(len(iobj) for iobj in objs)
  1153. self.assertGreater(len(objs), 0)
  1154. self.assertEqual(targwidth, len(targ.columns))
  1155. self.assertEqual(targwidth, len(res0.columns))
  1156. self.assertEqual(targlen, len(targ.index))
  1157. self.assertEqual(targlen, len(res0.index))
  1158. self.assertCountEqual(keys, targ.columns.names)
  1159. self.assertCountEqual(keys, res0.columns.names)
  1160. assert_array_equal(targ.values, res0.values)
  1161. assert_frame_equal(targ, res0)
  1162. def test__multi_spiketrains_to_dataframe__iter_default(self):
  1163. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1164. res0 = ep.multi_spiketrains_to_dataframe(iter(obj))
  1165. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in obj)
  1166. objs = list(chain.from_iterable(objs))
  1167. targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs]
  1168. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1169. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1170. child_first=True).keys()
  1171. keys = list(keys)
  1172. targwidth = len(objs)
  1173. targlen = max(len(iobj) for iobj in objs)
  1174. self.assertGreater(len(objs), 0)
  1175. self.assertEqual(targwidth, len(targ.columns))
  1176. self.assertEqual(targwidth, len(res0.columns))
  1177. self.assertEqual(targlen, len(targ.index))
  1178. self.assertEqual(targlen, len(res0.index))
  1179. self.assertCountEqual(keys, targ.columns.names)
  1180. self.assertCountEqual(keys, res0.columns.names)
  1181. assert_array_equal(targ.values, res0.values)
  1182. assert_frame_equal(targ, res0)
  1183. def test__multi_spiketrains_to_dataframe__dict_default(self):
  1184. obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3))
  1185. res0 = ep.multi_spiketrains_to_dataframe(obj)
  1186. objs = (iobj.list_children_by_class('SpikeTrain') for iobj in
  1187. obj.values())
  1188. objs = list(chain.from_iterable(objs))
  1189. targ = [ep.spiketrain_to_dataframe(iobj) for iobj in objs]
  1190. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1191. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1192. child_first=True).keys()
  1193. keys = list(keys)
  1194. targwidth = len(objs)
  1195. targlen = max(len(iobj) for iobj in objs)
  1196. self.assertGreater(len(objs), 0)
  1197. self.assertEqual(targwidth, len(targ.columns))
  1198. self.assertEqual(targwidth, len(res0.columns))
  1199. self.assertEqual(targlen, len(targ.index))
  1200. self.assertEqual(targlen, len(res0.index))
  1201. self.assertCountEqual(keys, targ.columns.names)
  1202. self.assertCountEqual(keys, res0.columns.names)
  1203. assert_array_equal(targ.values, res0.values)
  1204. assert_frame_equal(targ, res0)
  1205. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  1206. class MultiEventsToDataframeTestCase(unittest.TestCase):
  1207. def setUp(self):
  1208. if hasattr(self, 'assertItemsEqual'):
  1209. self.assertCountEqual = self.assertItemsEqual
  1210. def test__multi_events_to_dataframe__single(self):
  1211. obj = fake_neo('Event', seed=0, n=5)
  1212. res0 = ep.multi_events_to_dataframe(obj)
  1213. res1 = ep.multi_events_to_dataframe(obj, parents=False)
  1214. res2 = ep.multi_events_to_dataframe(obj, parents=True)
  1215. res3 = ep.multi_events_to_dataframe(obj, child_first=True)
  1216. res4 = ep.multi_events_to_dataframe(obj, parents=False,
  1217. child_first=True)
  1218. res5 = ep.multi_events_to_dataframe(obj, parents=True,
  1219. child_first=True)
  1220. res6 = ep.multi_events_to_dataframe(obj, child_first=False)
  1221. res7 = ep.multi_events_to_dataframe(obj, parents=False,
  1222. child_first=False)
  1223. res8 = ep.multi_events_to_dataframe(obj, parents=True,
  1224. child_first=False)
  1225. targ = ep.event_to_dataframe(obj)
  1226. keys = ep._extract_neo_attrs_safe(obj, parents=True,
  1227. child_first=True).keys()
  1228. keys = list(keys)
  1229. targwidth = 1
  1230. targlen = min(len(obj.times), len(obj.labels))
  1231. self.assertEqual(targwidth, len(targ.columns))
  1232. self.assertEqual(targwidth, len(res0.columns))
  1233. self.assertEqual(targwidth, len(res1.columns))
  1234. self.assertEqual(targwidth, len(res2.columns))
  1235. self.assertEqual(targwidth, len(res3.columns))
  1236. self.assertEqual(targwidth, len(res4.columns))
  1237. self.assertEqual(targwidth, len(res5.columns))
  1238. self.assertEqual(targwidth, len(res6.columns))
  1239. self.assertEqual(targwidth, len(res7.columns))
  1240. self.assertEqual(targwidth, len(res8.columns))
  1241. self.assertEqual(targlen, len(targ.index))
  1242. self.assertEqual(targlen, len(res0.index))
  1243. self.assertEqual(targlen, len(res1.index))
  1244. self.assertEqual(targlen, len(res2.index))
  1245. self.assertEqual(targlen, len(res3.index))
  1246. self.assertEqual(targlen, len(res4.index))
  1247. self.assertEqual(targlen, len(res5.index))
  1248. self.assertEqual(targlen, len(res6.index))
  1249. self.assertEqual(targlen, len(res7.index))
  1250. self.assertEqual(targlen, len(res8.index))
  1251. self.assertCountEqual(keys, targ.columns.names)
  1252. self.assertCountEqual(keys, res0.columns.names)
  1253. self.assertCountEqual(keys, res1.columns.names)
  1254. self.assertCountEqual(keys, res2.columns.names)
  1255. self.assertCountEqual(keys, res3.columns.names)
  1256. self.assertCountEqual(keys, res4.columns.names)
  1257. self.assertCountEqual(keys, res5.columns.names)
  1258. self.assertCountEqual(keys, res6.columns.names)
  1259. self.assertCountEqual(keys, res7.columns.names)
  1260. self.assertCountEqual(keys, res8.columns.names)
  1261. assert_array_equal(targ.values, res0.values)
  1262. assert_array_equal(targ.values, res1.values)
  1263. assert_array_equal(targ.values, res2.values)
  1264. assert_array_equal(targ.values, res3.values)
  1265. assert_array_equal(targ.values, res4.values)
  1266. assert_array_equal(targ.values, res5.values)
  1267. assert_array_equal(targ.values, res6.values)
  1268. assert_array_equal(targ.values, res7.values)
  1269. assert_array_equal(targ.values, res8.values)
  1270. assert_frame_equal(targ, res0)
  1271. assert_frame_equal(targ, res1)
  1272. assert_frame_equal(targ, res2)
  1273. assert_frame_equal(targ, res3)
  1274. assert_frame_equal(targ, res4)
  1275. assert_frame_equal(targ, res5)
  1276. assert_frame_equal(targ, res6)
  1277. assert_frame_equal(targ, res7)
  1278. assert_frame_equal(targ, res8)
  1279. def test__multi_events_to_dataframe__segment_default(self):
  1280. obj = fake_neo('Segment', seed=0, n=5)
  1281. res0 = ep.multi_events_to_dataframe(obj)
  1282. objs = obj.events
  1283. targ = [ep.event_to_dataframe(iobj) for iobj in objs]
  1284. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1285. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1286. child_first=True).keys()
  1287. keys = list(keys)
  1288. targwidth = len(objs)
  1289. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1290. for iobj in objs]
  1291. targlen = len(np.unique(np.hstack(targlen)))
  1292. self.assertGreater(len(objs), 0)
  1293. self.assertEqual(targwidth, len(targ.columns))
  1294. self.assertEqual(targwidth, len(res0.columns))
  1295. self.assertEqual(targlen, len(targ.index))
  1296. self.assertEqual(targlen, len(res0.index))
  1297. self.assertCountEqual(keys, targ.columns.names)
  1298. self.assertCountEqual(keys, res0.columns.names)
  1299. assert_array_equal(targ.values, res0.values)
  1300. assert_frame_equal(targ, res0)
  1301. def test__multi_events_to_dataframe__block_noparents(self):
  1302. obj = fake_neo('Block', seed=0, n=3)
  1303. res0 = ep.multi_events_to_dataframe(obj, parents=False)
  1304. res1 = ep.multi_events_to_dataframe(obj, parents=False,
  1305. child_first=True)
  1306. res2 = ep.multi_events_to_dataframe(obj, parents=False,
  1307. child_first=False)
  1308. objs = obj.list_children_by_class('Event')
  1309. targ = [ep.event_to_dataframe(iobj, parents=False, child_first=True)
  1310. for iobj in objs]
  1311. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1312. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  1313. child_first=True).keys()
  1314. keys = list(keys)
  1315. targwidth = len(objs)
  1316. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1317. for iobj in objs]
  1318. targlen = len(np.unique(np.hstack(targlen)))
  1319. self.assertGreater(len(objs), 0)
  1320. self.assertEqual(targwidth, len(targ.columns))
  1321. self.assertEqual(targwidth, len(res0.columns))
  1322. self.assertEqual(targwidth, len(res1.columns))
  1323. self.assertEqual(targwidth, len(res2.columns))
  1324. self.assertEqual(targlen, len(targ.index))
  1325. self.assertEqual(targlen, len(res0.index))
  1326. self.assertEqual(targlen, len(res1.index))
  1327. self.assertEqual(targlen, len(res2.index))
  1328. self.assertCountEqual(keys, targ.columns.names)
  1329. self.assertCountEqual(keys, res0.columns.names)
  1330. self.assertCountEqual(keys, res1.columns.names)
  1331. self.assertCountEqual(keys, res2.columns.names)
  1332. assert_array_equal(targ.values, res0.values)
  1333. assert_array_equal(targ.values, res1.values)
  1334. assert_array_equal(targ.values, res2.values)
  1335. assert_frame_equal(targ, res0)
  1336. assert_frame_equal(targ, res1)
  1337. assert_frame_equal(targ, res2)
  1338. def test__multi_events_to_dataframe__block_parents_childfirst(self):
  1339. obj = fake_neo('Block', seed=0, n=3)
  1340. res0 = ep.multi_events_to_dataframe(obj)
  1341. res1 = ep.multi_events_to_dataframe(obj, parents=True)
  1342. res2 = ep.multi_events_to_dataframe(obj, child_first=True)
  1343. res3 = ep.multi_events_to_dataframe(obj, parents=True,
  1344. child_first=True)
  1345. objs = obj.list_children_by_class('Event')
  1346. targ = [ep.event_to_dataframe(iobj, parents=True, child_first=True)
  1347. for iobj in objs]
  1348. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1349. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1350. child_first=True).keys()
  1351. keys = list(keys)
  1352. targwidth = len(objs)
  1353. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1354. for iobj in objs]
  1355. targlen = len(np.unique(np.hstack(targlen)))
  1356. self.assertGreater(len(objs), 0)
  1357. self.assertEqual(targwidth, len(targ.columns))
  1358. self.assertEqual(targwidth, len(res0.columns))
  1359. self.assertEqual(targwidth, len(res1.columns))
  1360. self.assertEqual(targwidth, len(res2.columns))
  1361. self.assertEqual(targwidth, len(res3.columns))
  1362. self.assertEqual(targlen, len(targ.index))
  1363. self.assertEqual(targlen, len(res0.index))
  1364. self.assertEqual(targlen, len(res1.index))
  1365. self.assertEqual(targlen, len(res2.index))
  1366. self.assertEqual(targlen, len(res3.index))
  1367. self.assertCountEqual(keys, targ.columns.names)
  1368. self.assertCountEqual(keys, res0.columns.names)
  1369. self.assertCountEqual(keys, res1.columns.names)
  1370. self.assertCountEqual(keys, res2.columns.names)
  1371. self.assertCountEqual(keys, res3.columns.names)
  1372. assert_array_equal(targ.values, res0.values)
  1373. assert_array_equal(targ.values, res1.values)
  1374. assert_array_equal(targ.values, res2.values)
  1375. assert_array_equal(targ.values, res3.values)
  1376. assert_frame_equal(targ, res0)
  1377. assert_frame_equal(targ, res1)
  1378. assert_frame_equal(targ, res2)
  1379. assert_frame_equal(targ, res3)
  1380. def test__multi_events_to_dataframe__block_parents_parentfirst(self):
  1381. obj = fake_neo('Block', seed=0, n=3)
  1382. res0 = ep.multi_events_to_dataframe(obj, child_first=False)
  1383. res1 = ep.multi_events_to_dataframe(obj, parents=True,
  1384. child_first=False)
  1385. objs = obj.list_children_by_class('Event')
  1386. targ = [ep.event_to_dataframe(iobj, parents=True, child_first=False)
  1387. for iobj in objs]
  1388. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1389. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1390. child_first=False).keys()
  1391. keys = list(keys)
  1392. targwidth = len(objs)
  1393. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1394. for iobj in objs]
  1395. targlen = len(np.unique(np.hstack(targlen)))
  1396. self.assertGreater(len(objs), 0)
  1397. self.assertEqual(targwidth, len(targ.columns))
  1398. self.assertEqual(targwidth, len(res0.columns))
  1399. self.assertEqual(targwidth, len(res1.columns))
  1400. self.assertEqual(targlen, len(targ.index))
  1401. self.assertEqual(targlen, len(res0.index))
  1402. self.assertEqual(targlen, len(res1.index))
  1403. self.assertCountEqual(keys, targ.columns.names)
  1404. self.assertCountEqual(keys, res0.columns.names)
  1405. self.assertCountEqual(keys, res1.columns.names)
  1406. assert_array_equal(targ.values, res0.values)
  1407. assert_array_equal(targ.values, res1.values)
  1408. assert_frame_equal(targ, res0)
  1409. assert_frame_equal(targ, res1)
  1410. def test__multi_events_to_dataframe__list_noparents(self):
  1411. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1412. res0 = ep.multi_events_to_dataframe(obj, parents=False)
  1413. res1 = ep.multi_events_to_dataframe(obj, parents=False,
  1414. child_first=True)
  1415. res2 = ep.multi_events_to_dataframe(obj, parents=False,
  1416. child_first=False)
  1417. objs = (iobj.list_children_by_class('Event') for iobj in obj)
  1418. objs = list(chain.from_iterable(objs))
  1419. targ = [ep.event_to_dataframe(iobj, parents=False, child_first=True)
  1420. for iobj in objs]
  1421. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1422. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  1423. child_first=True).keys()
  1424. keys = list(keys)
  1425. targwidth = len(objs)
  1426. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1427. for iobj in objs]
  1428. targlen = len(np.unique(np.hstack(targlen)))
  1429. self.assertGreater(len(objs), 0)
  1430. self.assertEqual(targwidth, len(targ.columns))
  1431. self.assertEqual(targwidth, len(res0.columns))
  1432. self.assertEqual(targwidth, len(res1.columns))
  1433. self.assertEqual(targwidth, len(res2.columns))
  1434. self.assertEqual(targlen, len(targ.index))
  1435. self.assertEqual(targlen, len(res0.index))
  1436. self.assertEqual(targlen, len(res1.index))
  1437. self.assertEqual(targlen, len(res2.index))
  1438. self.assertCountEqual(keys, targ.columns.names)
  1439. self.assertCountEqual(keys, res0.columns.names)
  1440. self.assertCountEqual(keys, res1.columns.names)
  1441. self.assertCountEqual(keys, res2.columns.names)
  1442. assert_array_equal(targ.values, res0.values)
  1443. assert_array_equal(targ.values, res1.values)
  1444. assert_array_equal(targ.values, res2.values)
  1445. assert_frame_equal(targ, res0)
  1446. assert_frame_equal(targ, res1)
  1447. assert_frame_equal(targ, res2)
  1448. def test__multi_events_to_dataframe__list_parents_childfirst(self):
  1449. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1450. res0 = ep.multi_events_to_dataframe(obj)
  1451. res1 = ep.multi_events_to_dataframe(obj, parents=True)
  1452. res2 = ep.multi_events_to_dataframe(obj, child_first=True)
  1453. res3 = ep.multi_events_to_dataframe(obj, parents=True,
  1454. child_first=True)
  1455. objs = (iobj.list_children_by_class('Event') for iobj in obj)
  1456. objs = list(chain.from_iterable(objs))
  1457. targ = [ep.event_to_dataframe(iobj, parents=True, child_first=True)
  1458. for iobj in objs]
  1459. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1460. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1461. child_first=True).keys()
  1462. keys = list(keys)
  1463. targwidth = len(objs)
  1464. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1465. for iobj in objs]
  1466. targlen = len(np.unique(np.hstack(targlen)))
  1467. self.assertGreater(len(objs), 0)
  1468. self.assertEqual(targwidth, len(targ.columns))
  1469. self.assertEqual(targwidth, len(res0.columns))
  1470. self.assertEqual(targwidth, len(res1.columns))
  1471. self.assertEqual(targwidth, len(res2.columns))
  1472. self.assertEqual(targwidth, len(res3.columns))
  1473. self.assertEqual(targlen, len(targ.index))
  1474. self.assertEqual(targlen, len(res0.index))
  1475. self.assertEqual(targlen, len(res1.index))
  1476. self.assertEqual(targlen, len(res2.index))
  1477. self.assertEqual(targlen, len(res3.index))
  1478. self.assertCountEqual(keys, targ.columns.names)
  1479. self.assertCountEqual(keys, res0.columns.names)
  1480. self.assertCountEqual(keys, res1.columns.names)
  1481. self.assertCountEqual(keys, res2.columns.names)
  1482. self.assertCountEqual(keys, res3.columns.names)
  1483. assert_array_equal(targ.values, res0.values)
  1484. assert_array_equal(targ.values, res1.values)
  1485. assert_array_equal(targ.values, res2.values)
  1486. assert_array_equal(targ.values, res3.values)
  1487. assert_frame_equal(targ, res0)
  1488. assert_frame_equal(targ, res1)
  1489. assert_frame_equal(targ, res2)
  1490. assert_frame_equal(targ, res3)
  1491. def test__multi_events_to_dataframe__list_parents_parentfirst(self):
  1492. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1493. res0 = ep.multi_events_to_dataframe(obj, child_first=False)
  1494. res1 = ep.multi_events_to_dataframe(obj, parents=True,
  1495. child_first=False)
  1496. objs = (iobj.list_children_by_class('Event') for iobj in obj)
  1497. objs = list(chain.from_iterable(objs))
  1498. targ = [ep.event_to_dataframe(iobj, parents=True, child_first=False)
  1499. for iobj in objs]
  1500. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1501. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1502. child_first=False).keys()
  1503. keys = list(keys)
  1504. targwidth = len(objs)
  1505. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1506. for iobj in objs]
  1507. targlen = len(np.unique(np.hstack(targlen)))
  1508. self.assertGreater(len(objs), 0)
  1509. self.assertEqual(targwidth, len(targ.columns))
  1510. self.assertEqual(targwidth, len(res0.columns))
  1511. self.assertEqual(targwidth, len(res1.columns))
  1512. self.assertEqual(targlen, len(targ.index))
  1513. self.assertEqual(targlen, len(res0.index))
  1514. self.assertEqual(targlen, len(res1.index))
  1515. self.assertCountEqual(keys, targ.columns.names)
  1516. self.assertCountEqual(keys, res0.columns.names)
  1517. self.assertCountEqual(keys, res1.columns.names)
  1518. assert_array_equal(targ.values, res0.values)
  1519. assert_array_equal(targ.values, res1.values)
  1520. assert_frame_equal(targ, res0)
  1521. assert_frame_equal(targ, res1)
  1522. def test__multi_events_to_dataframe__tuple_default(self):
  1523. obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3))
  1524. res0 = ep.multi_events_to_dataframe(obj)
  1525. objs = (iobj.list_children_by_class('Event') for iobj in obj)
  1526. objs = list(chain.from_iterable(objs))
  1527. targ = [ep.event_to_dataframe(iobj) for iobj in objs]
  1528. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1529. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1530. child_first=True).keys()
  1531. keys = list(keys)
  1532. targwidth = len(objs)
  1533. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1534. for iobj in objs]
  1535. targlen = len(np.unique(np.hstack(targlen)))
  1536. self.assertGreater(len(objs), 0)
  1537. self.assertEqual(targwidth, len(targ.columns))
  1538. self.assertEqual(targwidth, len(res0.columns))
  1539. self.assertEqual(targlen, len(targ.index))
  1540. self.assertEqual(targlen, len(res0.index))
  1541. self.assertCountEqual(keys, targ.columns.names)
  1542. self.assertCountEqual(keys, res0.columns.names)
  1543. assert_array_equal(targ.values, res0.values)
  1544. assert_frame_equal(targ, res0)
  1545. def test__multi_events_to_dataframe__iter_default(self):
  1546. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1547. res0 = ep.multi_events_to_dataframe(iter(obj))
  1548. objs = (iobj.list_children_by_class('Event') for iobj in obj)
  1549. objs = list(chain.from_iterable(objs))
  1550. targ = [ep.event_to_dataframe(iobj) for iobj in objs]
  1551. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1552. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1553. child_first=True).keys()
  1554. keys = list(keys)
  1555. targwidth = len(objs)
  1556. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1557. for iobj in objs]
  1558. targlen = len(np.unique(np.hstack(targlen)))
  1559. self.assertGreater(len(objs), 0)
  1560. self.assertEqual(targwidth, len(targ.columns))
  1561. self.assertEqual(targwidth, len(res0.columns))
  1562. self.assertEqual(targlen, len(targ.index))
  1563. self.assertEqual(targlen, len(res0.index))
  1564. self.assertCountEqual(keys, targ.columns.names)
  1565. self.assertCountEqual(keys, res0.columns.names)
  1566. assert_array_equal(targ.values, res0.values)
  1567. assert_frame_equal(targ, res0)
  1568. def test__multi_events_to_dataframe__dict_default(self):
  1569. obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3))
  1570. res0 = ep.multi_events_to_dataframe(obj)
  1571. objs = (iobj.list_children_by_class('Event') for iobj in
  1572. obj.values())
  1573. objs = list(chain.from_iterable(objs))
  1574. targ = [ep.event_to_dataframe(iobj) for iobj in objs]
  1575. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1576. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1577. child_first=True).keys()
  1578. keys = list(keys)
  1579. targwidth = len(objs)
  1580. targlen = [iobj.times[:min(len(iobj.times), len(iobj.labels))]
  1581. for iobj in objs]
  1582. targlen = len(np.unique(np.hstack(targlen)))
  1583. self.assertGreater(len(objs), 0)
  1584. self.assertEqual(targwidth, len(targ.columns))
  1585. self.assertEqual(targwidth, len(res0.columns))
  1586. self.assertEqual(targlen, len(targ.index))
  1587. self.assertEqual(targlen, len(res0.index))
  1588. self.assertCountEqual(keys, targ.columns.names)
  1589. self.assertCountEqual(keys, res0.columns.names)
  1590. assert_array_equal(targ.values, res0.values)
  1591. assert_frame_equal(targ, res0)
  1592. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  1593. class MultiEpochsToDataframeTestCase(unittest.TestCase):
  1594. def setUp(self):
  1595. if hasattr(self, 'assertItemsEqual'):
  1596. self.assertCountEqual = self.assertItemsEqual
  1597. def test__multi_epochs_to_dataframe__single(self):
  1598. obj = fake_neo('Epoch', seed=0, n=5)
  1599. res0 = ep.multi_epochs_to_dataframe(obj)
  1600. res1 = ep.multi_epochs_to_dataframe(obj, parents=False)
  1601. res2 = ep.multi_epochs_to_dataframe(obj, parents=True)
  1602. res3 = ep.multi_epochs_to_dataframe(obj, child_first=True)
  1603. res4 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1604. child_first=True)
  1605. res5 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1606. child_first=True)
  1607. res6 = ep.multi_epochs_to_dataframe(obj, child_first=False)
  1608. res7 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1609. child_first=False)
  1610. res8 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1611. child_first=False)
  1612. targ = ep.epoch_to_dataframe(obj)
  1613. keys = ep._extract_neo_attrs_safe(obj, parents=True,
  1614. child_first=True).keys()
  1615. keys = list(keys)
  1616. targwidth = 1
  1617. targlen = min(len(obj.times), len(obj.durations), len(obj.labels))
  1618. self.assertEqual(targwidth, len(targ.columns))
  1619. self.assertEqual(targwidth, len(res0.columns))
  1620. self.assertEqual(targwidth, len(res1.columns))
  1621. self.assertEqual(targwidth, len(res2.columns))
  1622. self.assertEqual(targwidth, len(res3.columns))
  1623. self.assertEqual(targwidth, len(res4.columns))
  1624. self.assertEqual(targwidth, len(res5.columns))
  1625. self.assertEqual(targwidth, len(res6.columns))
  1626. self.assertEqual(targwidth, len(res7.columns))
  1627. self.assertEqual(targwidth, len(res8.columns))
  1628. self.assertEqual(targlen, len(targ.index))
  1629. self.assertEqual(targlen, len(res0.index))
  1630. self.assertEqual(targlen, len(res1.index))
  1631. self.assertEqual(targlen, len(res2.index))
  1632. self.assertEqual(targlen, len(res3.index))
  1633. self.assertEqual(targlen, len(res4.index))
  1634. self.assertEqual(targlen, len(res5.index))
  1635. self.assertEqual(targlen, len(res6.index))
  1636. self.assertEqual(targlen, len(res7.index))
  1637. self.assertEqual(targlen, len(res8.index))
  1638. self.assertCountEqual(keys, targ.columns.names)
  1639. self.assertCountEqual(keys, res0.columns.names)
  1640. self.assertCountEqual(keys, res1.columns.names)
  1641. self.assertCountEqual(keys, res2.columns.names)
  1642. self.assertCountEqual(keys, res3.columns.names)
  1643. self.assertCountEqual(keys, res4.columns.names)
  1644. self.assertCountEqual(keys, res5.columns.names)
  1645. self.assertCountEqual(keys, res6.columns.names)
  1646. self.assertCountEqual(keys, res7.columns.names)
  1647. self.assertCountEqual(keys, res8.columns.names)
  1648. assert_array_equal(targ.values, res0.values)
  1649. assert_array_equal(targ.values, res1.values)
  1650. assert_array_equal(targ.values, res2.values)
  1651. assert_array_equal(targ.values, res3.values)
  1652. assert_array_equal(targ.values, res4.values)
  1653. assert_array_equal(targ.values, res5.values)
  1654. assert_array_equal(targ.values, res6.values)
  1655. assert_array_equal(targ.values, res7.values)
  1656. assert_array_equal(targ.values, res8.values)
  1657. assert_frame_equal(targ, res0)
  1658. assert_frame_equal(targ, res1)
  1659. assert_frame_equal(targ, res2)
  1660. assert_frame_equal(targ, res3)
  1661. assert_frame_equal(targ, res4)
  1662. assert_frame_equal(targ, res5)
  1663. assert_frame_equal(targ, res6)
  1664. assert_frame_equal(targ, res7)
  1665. assert_frame_equal(targ, res8)
  1666. def test__multi_epochs_to_dataframe__segment_default(self):
  1667. obj = fake_neo('Segment', seed=0, n=5)
  1668. res0 = ep.multi_epochs_to_dataframe(obj)
  1669. objs = obj.epochs
  1670. targ = [ep.epoch_to_dataframe(iobj) for iobj in objs]
  1671. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1672. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1673. child_first=True).keys()
  1674. keys = list(keys)
  1675. targwidth = len(objs)
  1676. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1677. len(iobj.labels))] for iobj in objs]
  1678. targlen = len(np.unique(np.hstack(targlen)))
  1679. self.assertGreater(len(objs), 0)
  1680. self.assertEqual(targwidth, len(targ.columns))
  1681. self.assertEqual(targwidth, len(res0.columns))
  1682. self.assertEqual(targlen, len(targ.index))
  1683. self.assertEqual(targlen, len(res0.index))
  1684. self.assertCountEqual(keys, targ.columns.names)
  1685. self.assertCountEqual(keys, res0.columns.names)
  1686. assert_array_equal(targ.values, res0.values)
  1687. assert_frame_equal(targ, res0)
  1688. def test__multi_epochs_to_dataframe__block_noparents(self):
  1689. obj = fake_neo('Block', seed=0, n=3)
  1690. res0 = ep.multi_epochs_to_dataframe(obj, parents=False)
  1691. res1 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1692. child_first=True)
  1693. res2 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1694. child_first=False)
  1695. objs = obj.list_children_by_class('Epoch')
  1696. targ = [ep.epoch_to_dataframe(iobj, parents=False, child_first=True)
  1697. for iobj in objs]
  1698. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1699. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  1700. child_first=True).keys()
  1701. keys = list(keys)
  1702. targwidth = len(objs)
  1703. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1704. len(iobj.labels))] for iobj in objs]
  1705. targlen = len(np.unique(np.hstack(targlen)))
  1706. self.assertGreater(len(objs), 0)
  1707. self.assertEqual(targwidth, len(targ.columns))
  1708. self.assertEqual(targwidth, len(res0.columns))
  1709. self.assertEqual(targwidth, len(res1.columns))
  1710. self.assertEqual(targwidth, len(res2.columns))
  1711. self.assertEqual(targlen, len(targ.index))
  1712. self.assertEqual(targlen, len(res0.index))
  1713. self.assertEqual(targlen, len(res1.index))
  1714. self.assertEqual(targlen, len(res2.index))
  1715. self.assertCountEqual(keys, targ.columns.names)
  1716. self.assertCountEqual(keys, res0.columns.names)
  1717. self.assertCountEqual(keys, res1.columns.names)
  1718. self.assertCountEqual(keys, res2.columns.names)
  1719. assert_array_equal(targ.values, res0.values)
  1720. assert_array_equal(targ.values, res1.values)
  1721. assert_array_equal(targ.values, res2.values)
  1722. assert_frame_equal(targ, res0)
  1723. assert_frame_equal(targ, res1)
  1724. assert_frame_equal(targ, res2)
  1725. def test__multi_epochs_to_dataframe__block_parents_childfirst(self):
  1726. obj = fake_neo('Block', seed=0, n=3)
  1727. res0 = ep.multi_epochs_to_dataframe(obj)
  1728. res1 = ep.multi_epochs_to_dataframe(obj, parents=True)
  1729. res2 = ep.multi_epochs_to_dataframe(obj, child_first=True)
  1730. res3 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1731. child_first=True)
  1732. objs = obj.list_children_by_class('Epoch')
  1733. targ = [ep.epoch_to_dataframe(iobj, parents=True, child_first=True)
  1734. for iobj in objs]
  1735. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1736. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1737. child_first=True).keys()
  1738. keys = list(keys)
  1739. targwidth = len(objs)
  1740. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1741. len(iobj.labels))] for iobj in objs]
  1742. targlen = len(np.unique(np.hstack(targlen)))
  1743. self.assertGreater(len(objs), 0)
  1744. self.assertEqual(targwidth, len(targ.columns))
  1745. self.assertEqual(targwidth, len(res0.columns))
  1746. self.assertEqual(targwidth, len(res1.columns))
  1747. self.assertEqual(targwidth, len(res2.columns))
  1748. self.assertEqual(targwidth, len(res3.columns))
  1749. self.assertEqual(targlen, len(targ.index))
  1750. self.assertEqual(targlen, len(res0.index))
  1751. self.assertEqual(targlen, len(res1.index))
  1752. self.assertEqual(targlen, len(res2.index))
  1753. self.assertEqual(targlen, len(res3.index))
  1754. self.assertCountEqual(keys, targ.columns.names)
  1755. self.assertCountEqual(keys, res0.columns.names)
  1756. self.assertCountEqual(keys, res1.columns.names)
  1757. self.assertCountEqual(keys, res2.columns.names)
  1758. self.assertCountEqual(keys, res3.columns.names)
  1759. assert_array_equal(targ.values, res0.values)
  1760. assert_array_equal(targ.values, res1.values)
  1761. assert_array_equal(targ.values, res2.values)
  1762. assert_array_equal(targ.values, res3.values)
  1763. assert_frame_equal(targ, res0)
  1764. assert_frame_equal(targ, res1)
  1765. assert_frame_equal(targ, res2)
  1766. assert_frame_equal(targ, res3)
  1767. def test__multi_epochs_to_dataframe__block_parents_parentfirst(self):
  1768. obj = fake_neo('Block', seed=0, n=3)
  1769. res0 = ep.multi_epochs_to_dataframe(obj, child_first=False)
  1770. res1 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1771. child_first=False)
  1772. objs = obj.list_children_by_class('Epoch')
  1773. targ = [ep.epoch_to_dataframe(iobj, parents=True, child_first=False)
  1774. for iobj in objs]
  1775. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1776. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1777. child_first=False).keys()
  1778. keys = list(keys)
  1779. targwidth = len(objs)
  1780. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1781. len(iobj.labels))] for iobj in objs]
  1782. targlen = len(np.unique(np.hstack(targlen)))
  1783. self.assertGreater(len(objs), 0)
  1784. self.assertEqual(targwidth, len(targ.columns))
  1785. self.assertEqual(targwidth, len(res0.columns))
  1786. self.assertEqual(targwidth, len(res1.columns))
  1787. self.assertEqual(targlen, len(targ.index))
  1788. self.assertEqual(targlen, len(res0.index))
  1789. self.assertEqual(targlen, len(res1.index))
  1790. self.assertCountEqual(keys, targ.columns.names)
  1791. self.assertCountEqual(keys, res0.columns.names)
  1792. self.assertCountEqual(keys, res1.columns.names)
  1793. assert_array_equal(targ.values, res0.values)
  1794. assert_array_equal(targ.values, res1.values)
  1795. assert_frame_equal(targ, res0)
  1796. assert_frame_equal(targ, res1)
  1797. def test__multi_epochs_to_dataframe__list_noparents(self):
  1798. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1799. res0 = ep.multi_epochs_to_dataframe(obj, parents=False)
  1800. res1 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1801. child_first=True)
  1802. res2 = ep.multi_epochs_to_dataframe(obj, parents=False,
  1803. child_first=False)
  1804. objs = (iobj.list_children_by_class('Epoch') for iobj in obj)
  1805. objs = list(chain.from_iterable(objs))
  1806. targ = [ep.epoch_to_dataframe(iobj, parents=False, child_first=True)
  1807. for iobj in objs]
  1808. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1809. keys = ep._extract_neo_attrs_safe(objs[0], parents=False,
  1810. child_first=True).keys()
  1811. keys = list(keys)
  1812. targwidth = len(objs)
  1813. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1814. len(iobj.labels))] for iobj in objs]
  1815. targlen = len(np.unique(np.hstack(targlen)))
  1816. self.assertGreater(len(objs), 0)
  1817. self.assertEqual(targwidth, len(targ.columns))
  1818. self.assertEqual(targwidth, len(res0.columns))
  1819. self.assertEqual(targwidth, len(res1.columns))
  1820. self.assertEqual(targwidth, len(res2.columns))
  1821. self.assertEqual(targlen, len(targ.index))
  1822. self.assertEqual(targlen, len(res0.index))
  1823. self.assertEqual(targlen, len(res1.index))
  1824. self.assertEqual(targlen, len(res2.index))
  1825. self.assertCountEqual(keys, targ.columns.names)
  1826. self.assertCountEqual(keys, res0.columns.names)
  1827. self.assertCountEqual(keys, res1.columns.names)
  1828. self.assertCountEqual(keys, res2.columns.names)
  1829. assert_array_equal(targ.values, res0.values)
  1830. assert_array_equal(targ.values, res1.values)
  1831. assert_array_equal(targ.values, res2.values)
  1832. assert_frame_equal(targ, res0)
  1833. assert_frame_equal(targ, res1)
  1834. assert_frame_equal(targ, res2)
  1835. def test__multi_epochs_to_dataframe__list_parents_childfirst(self):
  1836. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1837. res0 = ep.multi_epochs_to_dataframe(obj)
  1838. res1 = ep.multi_epochs_to_dataframe(obj, parents=True)
  1839. res2 = ep.multi_epochs_to_dataframe(obj, child_first=True)
  1840. res3 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1841. child_first=True)
  1842. objs = (iobj.list_children_by_class('Epoch') for iobj in obj)
  1843. objs = list(chain.from_iterable(objs))
  1844. targ = [ep.epoch_to_dataframe(iobj, parents=True, child_first=True)
  1845. for iobj in objs]
  1846. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1847. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1848. child_first=True).keys()
  1849. keys = list(keys)
  1850. targwidth = len(objs)
  1851. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1852. len(iobj.labels))] for iobj in objs]
  1853. targlen = len(np.unique(np.hstack(targlen)))
  1854. self.assertGreater(len(objs), 0)
  1855. self.assertEqual(targwidth, len(targ.columns))
  1856. self.assertEqual(targwidth, len(res0.columns))
  1857. self.assertEqual(targwidth, len(res1.columns))
  1858. self.assertEqual(targwidth, len(res2.columns))
  1859. self.assertEqual(targwidth, len(res3.columns))
  1860. self.assertEqual(targlen, len(targ.index))
  1861. self.assertEqual(targlen, len(res0.index))
  1862. self.assertEqual(targlen, len(res1.index))
  1863. self.assertEqual(targlen, len(res2.index))
  1864. self.assertEqual(targlen, len(res3.index))
  1865. self.assertCountEqual(keys, targ.columns.names)
  1866. self.assertCountEqual(keys, res0.columns.names)
  1867. self.assertCountEqual(keys, res1.columns.names)
  1868. self.assertCountEqual(keys, res2.columns.names)
  1869. self.assertCountEqual(keys, res3.columns.names)
  1870. assert_array_equal(targ.values, res0.values)
  1871. assert_array_equal(targ.values, res1.values)
  1872. assert_array_equal(targ.values, res2.values)
  1873. assert_array_equal(targ.values, res3.values)
  1874. assert_frame_equal(targ, res0)
  1875. assert_frame_equal(targ, res1)
  1876. assert_frame_equal(targ, res2)
  1877. assert_frame_equal(targ, res3)
  1878. def test__multi_epochs_to_dataframe__list_parents_parentfirst(self):
  1879. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1880. res0 = ep.multi_epochs_to_dataframe(obj, child_first=False)
  1881. res1 = ep.multi_epochs_to_dataframe(obj, parents=True,
  1882. child_first=False)
  1883. objs = (iobj.list_children_by_class('Epoch') for iobj in obj)
  1884. objs = list(chain.from_iterable(objs))
  1885. targ = [ep.epoch_to_dataframe(iobj, parents=True, child_first=False)
  1886. for iobj in objs]
  1887. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1888. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1889. child_first=False).keys()
  1890. keys = list(keys)
  1891. targwidth = len(objs)
  1892. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1893. len(iobj.labels))] for iobj in objs]
  1894. targlen = len(np.unique(np.hstack(targlen)))
  1895. self.assertGreater(len(objs), 0)
  1896. self.assertEqual(targwidth, len(targ.columns))
  1897. self.assertEqual(targwidth, len(res0.columns))
  1898. self.assertEqual(targwidth, len(res1.columns))
  1899. self.assertEqual(targlen, len(targ.index))
  1900. self.assertEqual(targlen, len(res0.index))
  1901. self.assertEqual(targlen, len(res1.index))
  1902. self.assertCountEqual(keys, targ.columns.names)
  1903. self.assertCountEqual(keys, res0.columns.names)
  1904. self.assertCountEqual(keys, res1.columns.names)
  1905. assert_array_equal(targ.values, res0.values)
  1906. assert_array_equal(targ.values, res1.values)
  1907. assert_frame_equal(targ, res0)
  1908. assert_frame_equal(targ, res1)
  1909. def test__multi_epochs_to_dataframe__tuple_default(self):
  1910. obj = tuple(fake_neo('Block', seed=i, n=3) for i in range(3))
  1911. res0 = ep.multi_epochs_to_dataframe(obj)
  1912. objs = (iobj.list_children_by_class('Epoch') for iobj in obj)
  1913. objs = list(chain.from_iterable(objs))
  1914. targ = [ep.epoch_to_dataframe(iobj) for iobj in objs]
  1915. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1916. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1917. child_first=True).keys()
  1918. keys = list(keys)
  1919. targwidth = len(objs)
  1920. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1921. len(iobj.labels))] for iobj in objs]
  1922. targlen = len(np.unique(np.hstack(targlen)))
  1923. self.assertGreater(len(objs), 0)
  1924. self.assertEqual(targwidth, len(targ.columns))
  1925. self.assertEqual(targwidth, len(res0.columns))
  1926. self.assertEqual(targlen, len(targ.index))
  1927. self.assertEqual(targlen, len(res0.index))
  1928. self.assertCountEqual(keys, targ.columns.names)
  1929. self.assertCountEqual(keys, res0.columns.names)
  1930. assert_array_equal(targ.values, res0.values)
  1931. assert_frame_equal(targ, res0)
  1932. def test__multi_epochs_to_dataframe__iter_default(self):
  1933. obj = [fake_neo('Block', seed=i, n=3) for i in range(3)]
  1934. res0 = ep.multi_epochs_to_dataframe(iter(obj))
  1935. objs = (iobj.list_children_by_class('Epoch') for iobj in obj)
  1936. objs = list(chain.from_iterable(objs))
  1937. targ = [ep.epoch_to_dataframe(iobj) for iobj in objs]
  1938. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1939. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1940. child_first=True).keys()
  1941. keys = list(keys)
  1942. targwidth = len(objs)
  1943. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1944. len(iobj.labels))] for iobj in objs]
  1945. targlen = len(np.unique(np.hstack(targlen)))
  1946. self.assertGreater(len(objs), 0)
  1947. self.assertEqual(targwidth, len(targ.columns))
  1948. self.assertEqual(targwidth, len(res0.columns))
  1949. self.assertEqual(targlen, len(targ.index))
  1950. self.assertEqual(targlen, len(res0.index))
  1951. self.assertCountEqual(keys, targ.columns.names)
  1952. self.assertCountEqual(keys, res0.columns.names)
  1953. assert_array_equal(targ.values, res0.values)
  1954. assert_frame_equal(targ, res0)
  1955. def test__multi_epochs_to_dataframe__dict_default(self):
  1956. obj = dict((i, fake_neo('Block', seed=i, n=3)) for i in range(3))
  1957. res0 = ep.multi_epochs_to_dataframe(obj)
  1958. objs = (iobj.list_children_by_class('Epoch') for iobj in
  1959. obj.values())
  1960. objs = list(chain.from_iterable(objs))
  1961. targ = [ep.epoch_to_dataframe(iobj) for iobj in objs]
  1962. targ = ep._sort_inds(pd.concat(targ, axis=1), axis=1)
  1963. keys = ep._extract_neo_attrs_safe(objs[0], parents=True,
  1964. child_first=True).keys()
  1965. keys = list(keys)
  1966. targwidth = len(objs)
  1967. targlen = [iobj.times[:min(len(iobj.times), len(iobj.durations),
  1968. len(iobj.labels))] for iobj in objs]
  1969. targlen = len(np.unique(np.hstack(targlen)))
  1970. self.assertGreater(len(objs), 0)
  1971. self.assertEqual(targwidth, len(targ.columns))
  1972. self.assertEqual(targwidth, len(res0.columns))
  1973. self.assertEqual(targlen, len(targ.index))
  1974. self.assertEqual(targlen, len(res0.index))
  1975. self.assertCountEqual(keys, targ.columns.names)
  1976. self.assertCountEqual(keys, res0.columns.names)
  1977. assert_array_equal(targ.values, res0.values)
  1978. assert_frame_equal(targ, res0)
  1979. @unittest.skipUnless(HAVE_PANDAS, 'requires pandas')
  1980. class SliceSpiketrainTestCase(unittest.TestCase):
  1981. def setUp(self):
  1982. obj = [fake_neo('SpikeTrain', seed=i, n=3) for i in range(10)]
  1983. self.obj = ep.multi_spiketrains_to_dataframe(obj)
  1984. def test_single_none(self):
  1985. targ_start = self.obj.columns.get_level_values('t_start').values
  1986. targ_stop = self.obj.columns.get_level_values('t_stop').values
  1987. res0 = ep.slice_spiketrain(self.obj)
  1988. res1 = ep.slice_spiketrain(self.obj, t_start=None)
  1989. res2 = ep.slice_spiketrain(self.obj, t_stop=None)
  1990. res3 = ep.slice_spiketrain(self.obj, t_start=None, t_stop=None)
  1991. res0_start = res0.columns.get_level_values('t_start').values
  1992. res1_start = res1.columns.get_level_values('t_start').values
  1993. res2_start = res2.columns.get_level_values('t_start').values
  1994. res3_start = res3.columns.get_level_values('t_start').values
  1995. res0_stop = res0.columns.get_level_values('t_stop').values
  1996. res1_stop = res1.columns.get_level_values('t_stop').values
  1997. res2_stop = res2.columns.get_level_values('t_stop').values
  1998. res3_stop = res3.columns.get_level_values('t_stop').values
  1999. targ = self.obj
  2000. self.assertFalse(res0 is targ)
  2001. self.assertFalse(res1 is targ)
  2002. self.assertFalse(res2 is targ)
  2003. self.assertFalse(res3 is targ)
  2004. assert_frame_equal(targ, res0)
  2005. assert_frame_equal(targ, res1)
  2006. assert_frame_equal(targ, res2)
  2007. assert_frame_equal(targ, res3)
  2008. assert_array_equal(targ_start, res0_start)
  2009. assert_array_equal(targ_start, res1_start)
  2010. assert_array_equal(targ_start, res2_start)
  2011. assert_array_equal(targ_start, res3_start)
  2012. assert_array_equal(targ_stop, res0_stop)
  2013. assert_array_equal(targ_stop, res1_stop)
  2014. assert_array_equal(targ_stop, res2_stop)
  2015. assert_array_equal(targ_stop, res3_stop)
  2016. def test_single_t_start(self):
  2017. targ_start = .0001
  2018. targ_stop = self.obj.columns.get_level_values('t_stop').values
  2019. res0 = ep.slice_spiketrain(self.obj, t_start=targ_start)
  2020. res1 = ep.slice_spiketrain(self.obj, t_start=targ_start, t_stop=None)
  2021. res0_start = res0.columns.get_level_values('t_start').unique().tolist()
  2022. res1_start = res1.columns.get_level_values('t_start').unique().tolist()
  2023. res0_stop = res0.columns.get_level_values('t_stop').values
  2024. res1_stop = res1.columns.get_level_values('t_stop').values
  2025. targ = self.obj.values
  2026. targ[targ < targ_start] = np.nan
  2027. self.assertFalse(res0 is targ)
  2028. self.assertFalse(res1 is targ)
  2029. assert_array_equal(targ, res0.values)
  2030. assert_array_equal(targ, res1.values)
  2031. self.assertEqual([targ_start], res0_start)
  2032. self.assertEqual([targ_start], res1_start)
  2033. assert_array_equal(targ_stop, res0_stop)
  2034. assert_array_equal(targ_stop, res1_stop)
  2035. def test_single_t_stop(self):
  2036. targ_start = self.obj.columns.get_level_values('t_start').values
  2037. targ_stop = .0009
  2038. res0 = ep.slice_spiketrain(self.obj, t_stop=targ_stop)
  2039. res1 = ep.slice_spiketrain(self.obj, t_stop=targ_stop, t_start=None)
  2040. res0_start = res0.columns.get_level_values('t_start').values
  2041. res1_start = res1.columns.get_level_values('t_start').values
  2042. res0_stop = res0.columns.get_level_values('t_stop').unique().tolist()
  2043. res1_stop = res1.columns.get_level_values('t_stop').unique().tolist()
  2044. targ = self.obj.values
  2045. targ[targ > targ_stop] = np.nan
  2046. self.assertFalse(res0 is targ)
  2047. self.assertFalse(res1 is targ)
  2048. assert_array_equal(targ, res0.values)
  2049. assert_array_equal(targ, res1.values)
  2050. assert_array_equal(targ_start, res0_start)
  2051. assert_array_equal(targ_start, res1_start)
  2052. self.assertEqual([targ_stop], res0_stop)
  2053. self.assertEqual([targ_stop], res1_stop)
  2054. def test_single_both(self):
  2055. targ_start = .0001
  2056. targ_stop = .0009
  2057. res0 = ep.slice_spiketrain(self.obj,
  2058. t_stop=targ_stop, t_start=targ_start)
  2059. res0_start = res0.columns.get_level_values('t_start').unique().tolist()
  2060. res0_stop = res0.columns.get_level_values('t_stop').unique().tolist()
  2061. targ = self.obj.values
  2062. targ[targ < targ_start] = np.nan
  2063. targ[targ > targ_stop] = np.nan
  2064. self.assertFalse(res0 is targ)
  2065. assert_array_equal(targ, res0.values)
  2066. self.assertEqual([targ_start], res0_start)
  2067. self.assertEqual([targ_stop], res0_stop)
  2068. if __name__ == '__main__':
  2069. unittest.main()