Example #1
0
    def test__pretty(self):
        res = pretty(self.blk1)
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')

        seg0 = pretty(self.segs1[0])
        seg1 = pretty(self.segs1[1])
        seg0 = seg0.replace('\n', '\n   ')
        seg1 = seg1.replace('\n', '\n   ')

        targ = ("Block with " +
                ("%s segments, %s recordingchannelgroups\n" %
                 (len(self.segs1), len(self.rcgs1))) +
                ("name: '%s'\ndescription: '%s'\n" % (self.blk1.name,
                                                      self.blk1.description)) +
                ("annotations: %s\n" % ann) +
                ("file_origin: '%s'\n" % self.blk1.file_origin) +
                ("file_datetime: %s\n" % repr(self.blk1.file_datetime)) +
                ("rec_datetime: %s\n" % repr(self.blk1.rec_datetime)) +
                ("index: %s\n" % self.blk1.index) +


                ("# segments (N=%s)\n" % len(self.segs1)) +
                ('%s: %s\n' % (0, seg0)) +
                ('%s: %s' % (1, seg1)))

        self.assertEqual(res, targ)
Example #2
0
    def check_creation(self, blk):
        assert_neo_object_is_compliant(blk)

        seed = blk.annotations['seed']

        targ0 = get_fake_value('file_datetime', datetime, seed=seed + 0)
        self.assertEqual(blk.file_datetime, targ0)

        targ1 = get_fake_value('rec_datetime', datetime, seed=seed + 1)
        self.assertEqual(blk.rec_datetime, targ1)

        targ2 = get_fake_value('index', int, seed=seed + 2, obj=Block)
        self.assertEqual(blk.index, targ2)

        targ3 = get_fake_value('name', str, seed=seed + 3, obj=Block)
        self.assertEqual(blk.name, targ3)

        targ4 = get_fake_value('description', str, seed=seed + 4, obj=Block)
        self.assertEqual(blk.description, targ4)

        targ5 = get_fake_value('file_origin', str)
        self.assertEqual(blk.file_origin, targ5)

        targ6 = get_annotations()
        targ6['seed'] = seed
        self.assertEqual(blk.annotations, targ6)

        self.assertTrue(hasattr(blk, 'channel_indexes'))
        self.assertTrue(hasattr(blk, 'segments'))

        self.assertEqual(len(blk.channel_indexes), self.nchildren)
        self.assertEqual(len(blk.segments), self.nchildren)
Example #3
0
    def check_creation(self, unit):
        assert_neo_object_is_compliant(unit)

        seed = unit.annotations['seed']

        targ0 = get_fake_value('channel_indexes', np.ndarray, dim=1, dtype='i',
                               seed=seed+0)
        assert_arrays_equal(unit.channel_indexes, targ0)

        targ1 = get_fake_value('name', str, seed=seed+1, obj=Unit)
        self.assertEqual(unit.name, targ1)

        targ2 = get_fake_value('description', str,
                               seed=seed+2, obj=Unit)
        self.assertEqual(unit.description, targ2)

        targ3 = get_fake_value('file_origin', str)
        self.assertEqual(unit.file_origin, targ3)

        targ4 = get_annotations()
        targ4['seed'] = seed
        self.assertEqual(unit.annotations, targ4)

        self.assertTrue(hasattr(unit, 'spikes'))
        self.assertTrue(hasattr(unit, 'spiketrains'))

        self.assertEqual(len(unit.spikes), self.nchildren)
        self.assertEqual(len(unit.spiketrains), self.nchildren)
    def check_creation(self, rcg):
        assert_neo_object_is_compliant(rcg)

        seed = rcg.annotations['seed']

        for i, rchan in enumerate(rcg.recordingchannels):
            self.assertEqual(rchan.name, rcg.channel_names[i].astype(str))
            self.assertEqual(rchan.index, rcg.channel_indexes[i])
        for i, unit in enumerate(rcg.units):
            for sigarr in rcg.analogsignalarrays:
                self.assertEqual(unit.channel_indexes[0],
                                 sigarr.channel_index[i])

        targ2 = get_fake_value('name', str, seed=seed+2,
                               obj=RecordingChannelGroup)
        self.assertEqual(rcg.name, targ2)

        targ3 = get_fake_value('description', str,
                               seed=seed+3, obj=RecordingChannelGroup)
        self.assertEqual(rcg.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(rcg.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(rcg.annotations, targ5)

        self.assertTrue(hasattr(rcg, 'recordingchannels'))
        self.assertTrue(hasattr(rcg, 'units'))
        self.assertTrue(hasattr(rcg, 'analogsignalarrays'))

        self.assertEqual(len(rcg.recordingchannels), self.nchildren)
        self.assertEqual(len(rcg.units), self.nchildren)
        self.assertEqual(len(rcg.analogsignalarrays), self.nchildren)
    def check_creation(self, chx):
        assert_neo_object_is_compliant(chx)

        seed = chx.annotations['seed']

        # for i, unit in enumerate(chx.units):
        #     for sigarr in chx.analogsignals:
        #         self.assertEqual(unit.channel_indexes[0],
        #                          sigarr.channel_index[i])

        targ2 = get_fake_value('name', str, seed=seed+4,
                               obj=ChannelIndex)
        self.assertEqual(chx.name, targ2)

        targ3 = get_fake_value('description', str,
                               seed=seed+5, obj=ChannelIndex)
        self.assertEqual(chx.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(chx.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(chx.annotations, targ5)

        self.assertTrue(hasattr(chx, 'units'))
        self.assertTrue(hasattr(chx, 'analogsignals'))

        self.assertEqual(len(chx.units), self.nchildren)
        self.assertEqual(len(chx.analogsignals), self.nchildren)
Example #6
0
    def check_creation(self, blk):
        assert_neo_object_is_compliant(blk)

        seed = blk.annotations['seed']

        targ0 = get_fake_value('file_datetime', datetime, seed=seed+0)
        self.assertEqual(blk.file_datetime, targ0)

        targ1 = get_fake_value('rec_datetime', datetime, seed=seed+1)
        self.assertEqual(blk.rec_datetime, targ1)

        targ2 = get_fake_value('index', int, seed=seed+2, obj=Block)
        self.assertEqual(blk.index, targ2)

        targ3 = get_fake_value('name', str, seed=seed+3, obj=Block)
        self.assertEqual(blk.name, targ3)

        targ4 = get_fake_value('description', str, seed=seed+4, obj=Block)
        self.assertEqual(blk.description, targ4)

        targ5 = get_fake_value('file_origin', str)
        self.assertEqual(blk.file_origin, targ5)

        targ6 = get_annotations()
        targ6['seed'] = seed
        self.assertEqual(blk.annotations, targ6)

        self.assertTrue(hasattr(blk, 'channel_indexes'))
        self.assertTrue(hasattr(blk, 'segments'))

        self.assertEqual(len(blk.channel_indexes), self.nchildren)
        self.assertEqual(len(blk.segments), self.nchildren)
Example #7
0
    def check_creation(self, chx):
        assert_neo_object_is_compliant(chx)

        seed = chx.annotations['seed']

        # for i, unit in enumerate(chx.units):
        #     for sigarr in chx.analogsignals:
        #         self.assertEqual(unit.channel_indexes[0],
        #                          sigarr.channel_index[i])

        targ2 = get_fake_value('name', str, seed=seed + 4, obj=ChannelIndex)
        self.assertEqual(chx.name, targ2)

        targ3 = get_fake_value('description',
                               str,
                               seed=seed + 5,
                               obj=ChannelIndex)
        self.assertEqual(chx.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(chx.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(chx.annotations, targ5)

        self.assertTrue(hasattr(chx, 'units'))
        self.assertTrue(hasattr(chx, 'analogsignals'))

        self.assertEqual(len(chx.units), self.nchildren)
        self.assertEqual(len(chx.analogsignals), self.nchildren)
    def check_creation(self, rchan):
        assert_neo_object_is_compliant(rchan)

        seed = rchan.annotations['seed']

        targ0 = get_fake_value('index', int, seed=seed+0, obj=RecordingChannel)
        self.assertEqual(rchan.index, targ0)

        targ1 = get_fake_value('coordinate', pq.Quantity, dim=1, seed=seed+1)
        assert_arrays_equal(rchan.coordinate, targ1)

        targ2 = get_fake_value('name', str, seed=seed+2, obj=RecordingChannel)
        self.assertEqual(rchan.name, targ2)

        targ3 = get_fake_value('description', str,
                               seed=seed+3, obj=RecordingChannel)
        self.assertEqual(rchan.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(rchan.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(rchan.annotations, targ5)

        self.assertTrue(hasattr(rchan, 'analogsignals'))
        self.assertTrue(hasattr(rchan, 'irregularlysampledsignals'))

        self.assertEqual(len(rchan.analogsignals), self.nchildren)
        self.assertEqual(len(rchan.irregularlysampledsignals), self.nchildren)
    def test__pretty(self):
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        res = pretty(self.rchan1)
        targ = ("RecordingChannel with " +
                ("%s analogsignals, %s irregularlysampledsignals\n" %
                 (len(self.sigs1), len(self.irsigs1))) +
                ("name: '%s'\ndescription: '%s'\n" %
                 (self.rchan1.name, self.rchan1.description)) +
                ("annotations: %s" % ann))

        self.assertEqual(res, targ)
Example #10
0
    def check_creation(self, seg):
        assert_neo_object_is_compliant(seg)

        seed = seg.annotations['seed']

        targ0 = get_fake_value('file_datetime', datetime, seed=seed+0)
        self.assertEqual(seg.file_datetime, targ0)

        targ1 = get_fake_value('rec_datetime', datetime, seed=seed+1)
        self.assertEqual(seg.rec_datetime, targ1)

        targ2 = get_fake_value('index', int, seed=seed+2)
        self.assertEqual(seg.index, targ2)

        targ3 = get_fake_value('name', str, seed=seed+3, obj=Segment)
        self.assertEqual(seg.name, targ3)

        targ4 = get_fake_value('description', str,
                               seed=seed+4, obj=Segment)
        self.assertEqual(seg.description, targ4)

        targ5 = get_fake_value('file_origin', str)
        self.assertEqual(seg.file_origin, targ5)

        targ6 = get_annotations()
        targ6['seed'] = seed
        self.assertEqual(seg.annotations, targ6)

        self.assertTrue(hasattr(seg, 'analogsignals'))
        self.assertTrue(hasattr(seg, 'analogsignalarrays'))
        self.assertTrue(hasattr(seg, 'irregularlysampledsignals'))

        self.assertTrue(hasattr(seg, 'epochs'))
        self.assertTrue(hasattr(seg, 'epocharrays'))
        self.assertTrue(hasattr(seg, 'events'))
        self.assertTrue(hasattr(seg, 'eventarrays'))

        self.assertTrue(hasattr(seg, 'spikes'))
        self.assertTrue(hasattr(seg, 'spiketrains'))

        self.assertEqual(len(seg.analogsignals), self.nchildren**2)
        self.assertEqual(len(seg.analogsignalarrays), self.nchildren)
        self.assertEqual(len(seg.irregularlysampledsignals), self.nchildren**2)

        self.assertEqual(len(seg.epochs), self.nchildren)
        self.assertEqual(len(seg.epocharrays), self.nchildren)
        self.assertEqual(len(seg.events), self.nchildren)
        self.assertEqual(len(seg.eventarrays), self.nchildren)

        self.assertEqual(len(seg.spikes), self.nchildren**2)
        self.assertEqual(len(seg.spiketrains), self.nchildren**2)
Example #11
0
    def test__pretty(self):
        res = pretty(self.rcg1)
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        targ = (
            "RecordingChannelGroup with " +
            ("%s units, %s analogsignalarrays, %s recordingchannels\n" %
             (len(self.units1a), len(self.sigarrs1a), len(self.rchans1a))) +
            ("name: '%s'\ndescription: '%s'\n" %
             (self.rcg1.name, self.rcg1.description)) +
            ("annotations: %s" % ann))

        self.assertEqual(res, targ)
Example #12
0
    def test__pretty(self):
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        res = pretty(self.seg1)

        sig0 = pretty(self.sigs1[0])
        sig1 = pretty(self.sigs1[1])
        sig2 = pretty(self.sigs1[2])
        sig3 = pretty(self.sigs1[3])
        sig0 = sig0.replace('\n', '\n   ')
        sig1 = sig1.replace('\n', '\n   ')
        sig2 = sig2.replace('\n', '\n   ')
        sig3 = sig3.replace('\n', '\n   ')

        sigarr0 = pretty(self.sigarrs1[0])
        sigarr1 = pretty(self.sigarrs1[1])
        sigarr0 = sigarr0.replace('\n', '\n   ')
        sigarr1 = sigarr1.replace('\n', '\n   ')

        targ = ("Segment with " +
                ("%s analogsignals, %s analogsignalarrays, " %
                 (len(self.sigs1a), len(self.sigarrs1a))) +
                ("%s epochs, %s epocharrays, " %
                 (len(self.epcs1a), len(self.epcas1a))) +
                ("%s events, %s eventarrays, " %
                 (len(self.evts1a), len(self.evtas1a))) +
                ("%s irregularlysampledsignals, " %
                 len(self.irsigs1a)) +
                ("%s spikes, %s spiketrains\n" %
                 (len(self.spikes1a), len(self.trains1a))) +
                ("name: '%s'\ndescription: '%s'\n" %
                 (self.seg1.name, self.seg1.description)
                 ) +

                ("annotations: %s\n" % ann) +

                ("# analogsignals (N=%s)\n" % len(self.sigs1a)) +

                ('%s: %s\n' % (0, sig0)) +
                ('%s: %s\n' % (1, sig1)) +
                ('%s: %s\n' % (2, sig2)) +
                ('%s: %s\n' % (3, sig3)) +

                ("# analogsignalarrays (N=%s)\n" % len(self.sigarrs1a)) +

                ('%s: %s\n' % (0, sigarr0)) +
                ('%s: %s' % (1, sigarr1)))

        self.assertEqual(res, targ)
Example #13
0
    def test__pretty(self):
        res = pretty(self.unit1)
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        targ = ("Unit with " +
                ("%s spikes, %s spiketrains\n" %
                 (len(self.spikes1a), len(self.trains1a))) +
                ("name: '%s'\ndescription: '%s'\n" % (self.unit1.name,
                                                      self.unit1.description)
                 ) +
                ("annotations: %s" % ann))

        self.assertEqual(res, targ)
    def test__pretty(self):
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        res = pretty(self.rchan1)
        targ = ("RecordingChannel with " +
                ("%s analogsignals, %s irregularlysampledsignals\n" %
                 (len(self.sigs1), len(self.irsigs1))) +
                ("name: '%s'\ndescription: '%s'\n" % (self.rchan1.name,
                                                      self.rchan1.description)
                 ) +
                ("annotations: %s" % ann))

        self.assertEqual(res, targ)
    def test__pretty(self):
        res = pretty(self.rcg1)
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')
        targ = ("RecordingChannelGroup with " +
                ("%s units, %s analogsignalarrays, %s recordingchannels\n" %
                 (len(self.units1a),
                  len(self.sigarrs1a),
                  len(self.rchans1a))) +
                ("name: '%s'\ndescription: '%s'\n" % (self.rcg1.name,
                                                      self.rcg1.description)
                 ) +
                ("annotations: %s" % ann))

        self.assertEqual(res, targ)
Example #16
0
    def check_creation(self, unit):
        assert_neo_object_is_compliant(unit)

        seed = unit.annotations['seed']

        targ1 = get_fake_value('name', str, seed=seed, obj=Unit)
        self.assertEqual(unit.name, targ1)

        targ2 = get_fake_value('description', str, seed=seed + 1, obj=Unit)
        self.assertEqual(unit.description, targ2)

        targ3 = get_fake_value('file_origin', str)
        self.assertEqual(unit.file_origin, targ3)

        targ4 = get_annotations()
        targ4['seed'] = seed
        self.assertEqual(unit.annotations, targ4)

        self.assertTrue(hasattr(unit, 'spiketrains'))

        self.assertEqual(len(unit.spiketrains), self.nchildren)
Example #17
0
    def check_creation(self, rcg):
        assert_neo_object_is_compliant(rcg)

        seed = rcg.annotations['seed']

        for i, rchan in enumerate(rcg.recordingchannels):
            self.assertEqual(rchan.name, rcg.channel_names[i].astype(str))
            self.assertEqual(rchan.index, rcg.channel_indexes[i])
        for i, unit in enumerate(rcg.units):
            for sigarr in rcg.analogsignalarrays:
                self.assertEqual(unit.channel_indexes[0],
                                 sigarr.channel_index[i])

        targ2 = get_fake_value('name',
                               str,
                               seed=seed + 2,
                               obj=RecordingChannelGroup)
        self.assertEqual(rcg.name, targ2)

        targ3 = get_fake_value('description',
                               str,
                               seed=seed + 3,
                               obj=RecordingChannelGroup)
        self.assertEqual(rcg.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(rcg.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(rcg.annotations, targ5)

        self.assertTrue(hasattr(rcg, 'recordingchannels'))
        self.assertTrue(hasattr(rcg, 'units'))
        self.assertTrue(hasattr(rcg, 'analogsignalarrays'))

        self.assertEqual(len(rcg.recordingchannels), self.nchildren)
        self.assertEqual(len(rcg.units), self.nchildren)
        self.assertEqual(len(rcg.analogsignalarrays), self.nchildren)
Example #18
0
    def check_creation(self, unit):
        assert_neo_object_is_compliant(unit)

        seed = unit.annotations['seed']

        targ1 = get_fake_value('name', str, seed=seed, obj=Unit)
        self.assertEqual(unit.name, targ1)

        targ2 = get_fake_value('description', str,
                               seed=seed + 1, obj=Unit)
        self.assertEqual(unit.description, targ2)

        targ3 = get_fake_value('file_origin', str)
        self.assertEqual(unit.file_origin, targ3)

        targ4 = get_annotations()
        targ4['seed'] = seed
        self.assertEqual(unit.annotations, targ4)

        self.assertTrue(hasattr(unit, 'spiketrains'))

        self.assertEqual(len(unit.spiketrains), self.nchildren)
    def check_creation(self, rchan):
        assert_neo_object_is_compliant(rchan)

        seed = rchan.annotations['seed']

        targ0 = get_fake_value('index',
                               int,
                               seed=seed + 0,
                               obj=RecordingChannel)
        self.assertEqual(rchan.index, targ0)

        targ1 = get_fake_value('coordinate', pq.Quantity, dim=1, seed=seed + 1)
        assert_arrays_equal(rchan.coordinate, targ1)

        targ2 = get_fake_value('name',
                               str,
                               seed=seed + 2,
                               obj=RecordingChannel)
        self.assertEqual(rchan.name, targ2)

        targ3 = get_fake_value('description',
                               str,
                               seed=seed + 3,
                               obj=RecordingChannel)
        self.assertEqual(rchan.description, targ3)

        targ4 = get_fake_value('file_origin', str)
        self.assertEqual(rchan.file_origin, targ4)

        targ5 = get_annotations()
        targ5['seed'] = seed
        self.assertEqual(rchan.annotations, targ5)

        self.assertTrue(hasattr(rchan, 'analogsignals'))
        self.assertTrue(hasattr(rchan, 'irregularlysampledsignals'))

        self.assertEqual(len(rchan.analogsignals), self.nchildren)
        self.assertEqual(len(rchan.irregularlysampledsignals), self.nchildren)
Example #20
0
    def test__pretty(self):
        res = pretty(self.blk1)
        ann = get_annotations()
        ann['seed'] = self.seed1
        ann = pretty(ann).replace('\n ', '\n  ')

        seg0 = pretty(self.segs1[0])
        seg1 = pretty(self.segs1[1])
        seg0 = seg0.replace('\n', '\n   ')
        seg1 = seg1.replace('\n', '\n   ')

        targ = ("Block with " + ("%s segments, %s recordingchannelgroups\n" %
                                 (len(self.segs1), len(self.rcgs1))) +
                ("name: '%s'\ndescription: '%s'\n" %
                 (self.blk1.name, self.blk1.description)) +
                ("annotations: %s\n" % ann) +
                ("file_origin: '%s'\n" % self.blk1.file_origin) +
                ("file_datetime: %s\n" % repr(self.blk1.file_datetime)) +
                ("rec_datetime: %s\n" % repr(self.blk1.rec_datetime)) +
                ("index: %s\n" % self.blk1.index) +
                ("# segments (N=%s)\n" % len(self.segs1)) +
                ('%s: %s\n' % (0, seg0)) + ('%s: %s' % (1, seg1)))

        self.assertEqual(res, targ)