def test_simple_moving_average(self):
     points = [1, 2, 3, 4, 5, 6]
     series = TimeSeries(zip(points, points))
     ma = series.moving_average(3).round()
     self.assertListEqual(ma.points, [ (3, 2), (4, 3), (5, 4), (6, 5) ])
     ma = series.moving_average(5).round()
     self.assertListEqual(ma.points, [ (5, 3), (6, 4) ])

 def test_itertimes(self):
     x = TimeSeries([1, 2, 3, 4],[1, 4, 9, 16])
     i = x.itertimes()
     nextt = next(i)
     self.assertTrue ( nextt == 1 )
     nextt = next(i)
     self.assertTrue ( nextt == 2 )
     self.assertTrue (nextt.dtype == np.int64)

 def test024(self):
     'TimeSeries.write_to_pi_file writes dict to stream with 12 offset'
     stream = mock.Stream()
     obj = TimeSeries.as_dict(self.testdata + "read.PI.timezone.2.xml")
     TimeSeries.write_to_pi_file(stream, obj, offset=12)
     target = file(self.testdata + "targetOutput12.xml").read()
     current = ''.join(stream.content)
     self.assertEquals(target.strip(), current.strip())

 def test_iteritems(self):
     x = TimeSeries([1, 2, 3, 4],[1, 4, 9, 16])
     i = x.iteritems()
     nextt = next(i)
     self.assertTrue ( nextt == (1, 1) )
     nextt = next(i)
     self.assertTrue ( nextt == (2, 4) )
     self.assertTrue (len(nextt) ==2 )

    def test_111(self):
        'get_event is defined and equal to __getitem__'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        ## setting
        obj[d1] = 1.23
        ## checking
        self.assertEquals(obj._events[d1], obj.get_event(d1))

    def test_024(self):
        'getting events of a eventless time series'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        d3 = datetime(1979, 4, 12, 9, 35)
        self.assertEqual(0, len(obj.get_events()))
        self.assertEqual(0, len(obj.get_events(d3)))
        self.assertEqual(0, len(obj.get_events(d1, d3)))

    def test_112(self):
        'get_value is defined returns only value, no flags'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        ## setting
        obj[d1] = 1.23
        ## checking
        self.assertEquals(obj._events[d1][0], obj.get_value(d1))

 def test000(self):
     'TimeSeries.write_to_pi_file writes list to new file'
     obj = TimeSeries.as_list(self.testdata + "read.PI.timezone.2.xml")
     TimeSeries.write_to_pi_file(self.testdata + "current.xml",
                                 obj,
                                 offset=2)
     target = file(self.testdata + "targetOutput.xml").read()
     current = file(self.testdata + "current.xml").read()
     self.assertEquals(target.strip(), current.strip())

 def test030(self):
     'TimeSeries.write_to_pi_file appends children to stream'
     stream = mock.Stream()
     obj = TimeSeries.as_dict(self.testdata + "read.PI.timezone.2.xml")
     TimeSeries.write_to_pi_file(stream, obj, offset=0, append=True)
     target_lines = file(self.testdata + "targetOutput00.xml").readlines()[3:-1]
     target = ''.join(i.strip() for i in target_lines)
     current = ''.join(i.strip() for i in ''.join(stream.content).split('\n'))
     self.assertEquals(target, current)

    def test_110(self):
        'add_value is defined and equal to __setitem__'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        ## setting
        obj.add_value(d1, 1.23)
        ## checking
        self.assertEquals(obj._events[d1], obj[d1])

 def test_periodic_decomposition(self):
     series = TimeSeries([ (1, 100), (2, 200), (3, 100), (4, 200), (5, 100) ])
     decomposed = series.decompose(2, periodic=True).round()
     self.assertTrue(isinstance(decomposed, DataFrame))
     self.assertEquals(len(decomposed), 3)
     for series in decomposed.itervalues():
         self.assertListEqual(series.timestamps, [1, 2, 3, 4, 5])
     self.assertListEqual(decomposed['trend'].values, [150] * 5)
     self.assertListEqual(decomposed['seasonal'].values, [-50, 50, -50, 50, -50])
     self.assertListEqual(decomposed['residual'].values, [0] * 5)

    def test_022(self):
        'start and end of a time series with events'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        d3 = datetime(1979, 4, 12, 9, 35)
        d2 = datetime(1979, 5, 15, 9, 35)
        obj[d1] = 1.23
        obj[d3] = 0.23
        obj[d2] = -3.01
        self.assertEqual(d1, obj.get_start_date())
        self.assertEqual(d2, obj.get_end_date())

    def test_115(self):
        'can use .get with default value'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        obj.add_value(d1, 1.23)  # executing __setitem__
        ## finds values that are there
        [self.assertEquals(obj._events[d], obj.get(d))
         for d in obj._events.keys()]
        d2 = datetime(1979, 5, 15, 9, 35)
        ## returns default value if event is not there
        self.assertEquals(None, obj.get(d2))

    def test_200(self):
        'represent empty TimeSeries as Element'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        
        current = obj._as_element()
        self.assertTrue(isinstance(current, ElementTree.Element))
        self.assertEquals('series', current.tag)
        childElements = [i for i in current.getchildren()]
        self.assertEquals(1, len(childElements))
        self.assertEquals(['header'], [i.tag for i in childElements])
        self.assertEquals({}, current.attrib)

    def test_023(self):
        'getting events of a non empty time series'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        d3 = datetime(1979, 4, 12, 9, 35)
        d2 = datetime(1979, 5, 15, 9, 35)
        obj[d1] = 1.23
        obj[d3] = 0.23
        obj[d2] = -3.01
        self.assertEqual(3, len(obj.get_events()))
        self.assertEqual(2, len(obj.get_events(d3)))
        self.assertEqual(2, len(obj.get_events(d1, d3)))

    def test_201(self):
        'represent TimeSeries with two events as Element'

        obj = TimeSeries(location_id='loc', parameter_id='par')
        obj[datetime(1980, 11, 23, 19, 35)] = -1
        
        current = obj._as_element()
        self.assertTrue(isinstance(current, ElementTree.Element))
        self.assertEquals('series', current.tag)
        childElements = [i for i in current.getchildren()]
        self.assertEquals(2, len(childElements))
        self.assertEquals(['header', 'event'],
                          [i.tag for i in childElements])
        self.assertEquals({}, current.attrib)

 def test010(self):
     '''result of TimeSeries.as_dict is indexed on locationId
     parameterId 2-tuples'''
     obj = TimeSeries.as_dict(self.testdata + "read.PI.timezone.2.xml")
     self.assertEquals(set([("600", "P1201"), ("600", "P2504")]),
                       set(obj.keys()))
     self.assertTrue(isinstance(obj[("600", "P1201")], TimeSeries))
     self.assertTrue(isinstance(obj[("600", "P2504")], TimeSeries))

 def test111(self):
     'TimeSeries.as_dict reads events of series (b)'
     obj = TimeSeries.as_dict(self.testdata + "read.PI.timezone.2.xml")
     ts = obj[("600", "P2504")]
     self.assertEquals([
             (str_to_datetime("2010-04-05", "00:00:00", 2), 17),
             (str_to_datetime("2010-04-08", "00:00:00", 2), 22),
             (str_to_datetime("2010-04-10", "00:00:00", 2), 24), ],
                       ts.get_values())

 def test113(self):
     'TimeSeries.get_values with only requested timeseries'
     obj = TimeSeries.as_dict(self.testdata + "read.PI.timezone.2.xml")
     ts = obj[("600", "P2504")]
     dates = [str_to_datetime("2010-04-05", "00:00:00", 2),
              str_to_datetime("2010-04-10", "00:00:00", 2)]
     self.assertEquals([
             (str_to_datetime("2010-04-05", "00:00:00", 2), (17, 0, '')),
             (str_to_datetime("2010-04-10", "00:00:00", 2), (24, 0, '')), ],
                       ts.get_events(dates=dates))

    def test_042(self):
        'using deprecated events function'

        root = logging.getLogger()
        handler = mock.Handler()
        root.addHandler(handler)
        obj = TimeSeries(location_id='loc', parameter_id='par')
        d1 = datetime(1979, 3, 15, 9, 35)
        d3 = datetime(1979, 4, 12, 9, 35)
        d2 = datetime(1979, 5, 15, 9, 35)
        obj[d1] = 1.23
        obj[d3] = 0.23
        obj[d2] = -3.01
        self.assertEqual(62, len(list(obj.events())))
        self.assertEqual(34, len(list(obj.events(d3))))
        self.assertEqual(29, len(list(obj.events(d1, d3))))
        self.assertEqual(3, len(handler.content))
        self.assertEqual("timeseries.timeseries|WARNING|Call to deprecated function events.",
                         handler.content[0])
        root.removeHandler(handler)