def test_padding_gap(self):
        """
        Test padding a TimeSeries with a large gap.
        """
        ts_missing = TimeSeries()
        ts_missing.array.resize(3)
        ts_missing.array[0] = (np.uint32(1), np.float32(1.0))
        ts_missing.array[1] = (np.uint32(3), np.float32(3.0))
        ts_missing.array[2] = (np.uint32(8), np.float32(0.0))

        ts_test = TimeSeries()
        ts_test.array.resize(4)
        ts_test.array[0] = (np.uint32(1), np.float32(1.0))
        ts_test.array[1] = (np.uint32(2), np.float32(1.0))
        ts_test.array[2] = (np.uint32(3), np.float32(3.0))
        ts_test.array[3] = (np.uint32(8), np.float32(0.0))

        ts_missing.pad(3)

        self.assertItemsEqual(ts_missing.powers, ts_test.powers)
    def test_padding(self):
        """
        Test padding a TimeSeries with missing values.
        """
        ts_missing = TimeSeries()
        ts_missing.array.resize(3)
        ts_missing.array[0] = (np.uint32(1), np.float32(1.0))
        ts_missing.array[1] = (np.uint32(3), np.float32(3.0))
        ts_missing.array[2] = (np.uint32(5), np.float32(0.0))

        ts_test = TimeSeries()
        ts_test.array.resize(5)
        ts_test.array[0] = (np.uint32(1), np.float32(1.0))
        ts_test.array[1] = (np.uint32(2), np.float32(1.0))
        ts_test.array[2] = (np.uint32(3), np.float32(3.0))
        ts_test.array[3] = (np.uint32(4), np.float32(3.0))
        ts_test.array[4] = (np.uint32(5), np.float32(0.0))

        ts_missing.pad(5)

        self.assertItemsEqual(ts_missing.powers, ts_test.powers)
def main():
    parser = get_parser()
    args = parser.parse_args()
    logging.basicConfig(filename=args.log, level=logging.DEBUG)
    log = logging.getLogger(__name__)

    device_files = [os.path.abspath(os.path.join(args.dir, p)) for p in
                    os.listdir(args.dir)]
    for dev_path in args.devices:
        try:
            device_files.remove(os.path.abspath(dev_path))
            dev_data = TimeSeries(os.path.basename(dev_path).split('.')[0],
                                  path=os.path.abspath(dev_path))
            dev_data.pad(600)
            dev_data.write(os.path.join(args.out, dev_data.name + '.dat'))
        except ValueError:
            log.error('Unable to find device file %s under %s' % (dev_path,
                                                                  args.dir))

    for agg_path in args.aggregated:
        try:
            device_files.remove(os.path.abspath(agg_path))
        except ValueError:
            log.warning('Unable to find aggregated power file %s under %s' %
                        (agg_path, args.dir))

    agg_data = TimeSeries(path=os.path.abspath(args.aggregated[0]))
    agg_data.pad(600)
    for agg_path in args.aggregated[1:]:
        agg_in = TimeSeries(path=os.path.abspath(agg_path))
        agg_in.pad(600)
        agg_data += agg_in

    for dev_path in device_files:
        dev_data = TimeSeries(path=dev_path)
        dev_data.pad(600)

        agg_data -= dev_data

    agg_data.write(os.path.join(args.out, 'aggregate.dat'))

    return 0