Merge pull request #20 from tessgi/refactor-dataframe

Renamed Frame products to SeriesCollection

Author: d-giles

src/lkdata/__init__.py

@@ -3,21 +3,25 @@
 from __future__ import absolute_import
 from .version import __version__  # noqa: E402, F401
 from .datacube import DataCube, BoolCube, BitwiseCube  # noqa: F403, E402
-from .dataframe import DataFrame, BoolFrame, BitwiseFrame  # noqa: F403, E402
+from .seriescollection import (
+    DataSeriesCollection,
+    BoolSeriesCollection,
+    BitwiseSeriesCollection,
+)  # noqa: F403, E402
 from .dataseries import DataSeries, BoolSeries, BitwiseSeries  # noqa: F403, E402
 from .dataset import DataSet  # noqa: E402
 import os
 
 __all__ = [
     "DataCube",
-    "DataFrame",
+    "DataSeriesCollection",
     "DataSeries",
     "DataSet",
     "BoolCube",
-    "BoolFrame",
+    "BoolSeriesCollection",
     "BoolSeries",
     "BitwiseCube",
-    "BitwiseFrame",
+    "BitwiseSeriesCollection",
     "BitwiseSeries",
 ]
 

src/lkdata/datacube.py

@@ -8,7 +8,11 @@
 import numpy as np
 from typing import Union, List, Dict, Optional
 
-from .dataframe import DataFrame, BoolFrame, BitwiseFrame
+from .seriescollection import (
+    DataSeriesCollection,
+    BoolSeriesCollection,
+    BitwiseSeriesCollection,
+)
 from .dataseries import DataSeries, BoolSeries, BitwiseSeries
 from .mixins import (
     StatsMixin,
@@ -480,7 +484,7 @@ def to_dataframe(
         row: Union[int, float, list, slice],
         col: Union[int, float, list, slice],
         **kwargs,
-    ) -> DataFrame:
+    ) -> DataSeriesCollection:
         """Convert lkdata.Cube to lkdata.Frame with the given row and column.
 
         Parameters
@@ -528,7 +532,7 @@ class DataCube(
 ):
     """A Cube object which contains data with time and 2 spatial dimensions."""
 
-    _frame_class = DataFrame
+    _frame_class = DataSeriesCollection
     _series_class = DataSeries
 
     def __init__(
@@ -570,7 +574,7 @@ class BoolCube(
 ):
     """A Cube object which contains boolean values with time and 2 spatial dimensions."""
 
-    _frame_class = BoolFrame
+    _frame_class = BoolSeriesCollection
     _series_class = BoolSeries
 
     def __init__(
@@ -596,7 +600,7 @@ def __repr__(self):
 class BitwiseCube(BitwiseMixin, Cube):
     """A Cube object which contains bitwise values with time and 2 spatial dimensions."""
 
-    _frame_class = BitwiseFrame
+    _frame_class = BitwiseSeriesCollection
     _series_class = BitwiseSeries
 
     def __init__(

src/lkdata/dataset.py

@@ -12,22 +12,27 @@
 import pandas as pd
 
 from .datacube import Cube, DataCube, BoolCube, BitwiseCube
-from .dataframe import Frame, DataFrame, BoolFrame, BitwiseFrame
+from .seriescollection import (
+    SeriesCollection,
+    DataSeriesCollection,
+    BoolSeriesCollection,
+    BitwiseSeriesCollection,
+)
 from .dataseries import Series, DataSeries, BoolSeries, BitwiseSeries
 from .mixins import IndexProcessorMixin
 
-LkDataTypes = Union[DataCube, DataFrame, DataSeries]
-LkBoolTypes = Union[BoolCube, BoolFrame, BoolSeries]
-LkBitwiseTypes = Union[BitwiseCube, BitwiseFrame, BitwiseSeries]
+LkDataTypes = Union[DataCube, DataSeriesCollection, DataSeries]
+LkBoolTypes = Union[BoolCube, BoolSeriesCollection, BoolSeries]
+LkBitwiseTypes = Union[BitwiseCube, BitwiseSeriesCollection, BitwiseSeries]
 LkTypes = Union[LkDataTypes, LkBoolTypes, LkBitwiseTypes]
 
 CLS_STRINGS = {
     DataCube: "DataCube",
     BoolCube: "BoolCube",
     BitwiseCube: "BitwiseCube",
-    DataFrame: "DataFrame",
-    BoolFrame: "BoolFrame",
-    BitwiseFrame: "BitwiseFrame",
+    DataSeriesCollection: "DataFrame",
+    BoolSeriesCollection: "BoolFrame",
+    BitwiseSeriesCollection: "BitwiseFrame",
     DataSeries: "DataSeries",
     BoolSeries: "BoolSeries",
     BitwiseSeries: "BitwiseSeries",
@@ -182,13 +187,13 @@ def process_input(self, input_data) -> LkTypes:
         """
 
     @process_input.register(DataCube)
-    @process_input.register(DataFrame)
+    @process_input.register(DataSeriesCollection)
     @process_input.register(DataSeries)
     @process_input.register(BoolCube)
-    @process_input.register(BoolFrame)
+    @process_input.register(BoolSeriesCollection)
     @process_input.register(BoolSeries)
     @process_input.register(BitwiseCube)
-    @process_input.register(BitwiseFrame)
+    @process_input.register(BitwiseSeriesCollection)
     @process_input.register(BitwiseSeries)
     def _(self, input_data):
         self._check_attrs(input_data)
@@ -230,7 +235,7 @@ class ProductBundle(dict, DataProcessorMixin):
 
     _type: str = None
     _cube: Cube = Cube
-    _frame: Frame = Frame
+    _frame: SeriesCollection = SeriesCollection
     _series: Series = Series
 
     _index: pd.MultiIndex = None
@@ -318,13 +323,13 @@ def _(self, input_data: dict):
         return input_data
 
     @_unpack_input.register(DataCube)
-    @_unpack_input.register(DataFrame)
+    @_unpack_input.register(DataSeriesCollection)
     @_unpack_input.register(DataSeries)
     @_unpack_input.register(BoolCube)
-    @_unpack_input.register(BoolFrame)
+    @_unpack_input.register(BoolSeriesCollection)
     @_unpack_input.register(BoolSeries)
     @_unpack_input.register(BitwiseCube)
-    @_unpack_input.register(BitwiseFrame)
+    @_unpack_input.register(BitwiseSeriesCollection)
     @_unpack_input.register(BitwiseSeries)
     def _(self, input_data):
         default_key = CLS_STRINGS.get(type(input_data))
@@ -388,7 +393,7 @@ class DataProducts(ProductBundle):
 
     _type = "data"
     _cube = DataCube
-    _frame = DataFrame
+    _frame = DataSeriesCollection
     _series = DataSeries
 
     def __init__(
@@ -406,7 +411,7 @@ def __init__(
 class BoolProducts(ProductBundle):
     _type = "bool"
     _cube = BoolCube
-    _frame = BoolFrame
+    _frame = BoolSeriesCollection
     _series = BoolSeries
 
     def __init__(
@@ -424,7 +429,7 @@ def __init__(
 class BitwiseProducts(ProductBundle):
     _type = "bitwise"
     _cube = BitwiseCube
-    _frame = BitwiseFrame
+    _frame = BitwiseSeriesCollection
     _series = BitwiseSeries
 
     def __init__(
@@ -586,7 +591,7 @@ def _(self, key: tuple):
             {
                 data_key: data[time_key]
                 for data_key, data in self.data_products.items()
-                if isinstance(data, (DataSeries, DataFrame))
+                if isinstance(data, (DataSeries, DataSeriesCollection))
             }
         )
 
@@ -611,7 +616,7 @@ def _(self, key: tuple):
             {
                 data_key: data[time_key]
                 for data_key, data in self.bool_products.items()
-                if isinstance(data, (BoolSeries, BoolFrame))
+                if isinstance(data, (BoolSeries, BoolSeriesCollection))
             }
         )
 
@@ -631,7 +636,7 @@ def _(self, key: tuple):
             {
                 data_key: data[time_key]
                 for data_key, data in self.bitwise_products.items()
-                if isinstance(data, (BitwiseSeries, BitwiseFrame))
+                if isinstance(data, (BitwiseSeries, BitwiseSeriesCollection))
             }
         )
 
@@ -769,7 +774,7 @@ def frames(self) -> dict:
         frames = {
             key: value
             for key, value in self.contents.items()
-            if issubclass(type(value), Frame)
+            if issubclass(type(value), SeriesCollection)
         }
         return frames
 

src/lkdata/dataframe.py src/lkdata/seriescollection.pysrc/lkdata/dataframe.py renamed to src/lkdata/seriescollection.py

@@ -6,7 +6,7 @@
 from lkdata import (
     TESTDATA,
     DataCube,
-    DataFrame,
+    DataSeriesCollection,
     DataSeries,
     BoolCube,
 )
@@ -115,12 +115,12 @@ def test_slicing():
     assert df[:, :2, :2].ncol == 2
 
     # Mixed slice and indices
-    assert isinstance(df[:, [0, 1], :2], DataFrame)
+    assert isinstance(df[:, [0, 1], :2], DataSeriesCollection)
     assert df[:, [0, 1], :2].ntime == ntime
     assert df[:, [0, 1], :2].nseries == 4
 
     assert all(df[:, [0, 1], 0] == df[:, [0, 1], [0, 0]])
-    assert isinstance(df[:, [0, 1], 0], DataFrame)
+    assert isinstance(df[:, [0, 1], 0], DataSeriesCollection)
     assert df[:, [0, 1], 0].ntime == ntime
     assert df[:, [0, 1], 0].nseries == 2
 
@@ -130,27 +130,27 @@ def test_slicing():
 
     # Frames - timeseries for multiple pixels
     row, col = np.where(aperture)
-    assert isinstance(df[:, row, col], DataFrame)
+    assert isinstance(df[:, row, col], DataSeriesCollection)
     assert df[:, row, col].ntime == ntime
     assert df[:, row, col].shape == (ntime, 9)
 
-    assert isinstance(df[:, [1, 2, 3], [1, 2, 3]], DataFrame)
+    assert isinstance(df[:, [1, 2, 3], [1, 2, 3]], DataSeriesCollection)
     assert df[:, [1, 2, 3], [1, 2, 3]].ntime == ntime
     assert df[:, [1, 2, 3], [1, 2, 3]].shape == (ntime, 3)
 
-    assert isinstance(df[:, 0, :], DataFrame)
+    assert isinstance(df[:, 0, :], DataSeriesCollection)
     assert df[:, 0, :].ntime == ntime
     assert df[:, 0, :].shape == (ntime, ncol)
 
-    assert isinstance(df[:, :, 0], DataFrame)
+    assert isinstance(df[:, :, 0], DataSeriesCollection)
     assert df[:, :, 0].ntime == ntime
     assert df[:, :, 0].shape == (ntime, nrow)
 
-    assert isinstance(df[:, :1, [1, 2]], DataFrame)
+    assert isinstance(df[:, :1, [1, 2]], DataSeriesCollection)
     assert df[:, :1, [1, 2]].ntime == ntime
     assert df[:, :1, [1, 2]].shape == (ntime, 2)
 
-    assert isinstance(df[:, [0, 1], [1, 2]], DataFrame)
+    assert isinstance(df[:, [0, 1], [1, 2]], DataSeriesCollection)
     assert df[:, [0, 1], [1, 2]].ntime == ntime
     assert df[:, [0, 1], [1, 2]].shape == (ntime, 2)
 
@@ -359,7 +359,7 @@ def test_real_data():
     assert flux.downsample(5).array.shape == (8, 6, 6)
     assert flux.downsample(5).uncertainty.array.shape == (8, 6, 6)
 
-    assert isinstance(flux[:, aper], DataFrame)
+    assert isinstance(flux[:, aper], DataSeriesCollection)
     assert isinstance(flux[:, aper].uncertainty, Uncertainty)
 
     assert isinstance(flux[:, aper].sum(axis=1), DataSeries)
@@ -429,7 +429,7 @@ def test_bool_cube():
 
 def test_bit_cube():
     """Test BitwiseCube methods"""
-    from lkdata import BitwiseCube, BitwiseFrame, BitwiseSeries
+    from lkdata import BitwiseCube, BitwiseSeriesCollection, BitwiseSeries
 
     def strip(string):
         return string.replace(" ", "").replace("\n", "")
@@ -480,7 +480,7 @@ def strip(string):
     ).all()
 
     # Frames
-    assert isinstance(bitcube[:, [0, 1, 2, 3], :], BitwiseFrame)
+    assert isinstance(bitcube[:, [0, 1, 2, 3], :], BitwiseSeriesCollection)
     bitframe = bitcube[:, [0, 1, 2, 3], :]
     assert bitframe.shape == (2, 16)
     # Ensure codes and values_display transferred to derivative product
@@ -499,7 +499,7 @@ def strip(string):
         "8:'C8',16:'C16'}{1:'C1',2:'C2',4:'C4',8:'C8',16:'C16'}"
     )
 
-    bitframe = BitwiseFrame(np.arange(0, 32).reshape(2, 16))
+    bitframe = BitwiseSeriesCollection(np.arange(0, 32).reshape(2, 16))
     # New bitframe has no codes_dict, detailed display should be the same as bitset
     bitframe.values_display = "bitset"
     bitset_str = strip(bitframe.styler.to_string())

tests/test_datacube.py

@@ -8,7 +8,11 @@
     DataSet,
 )
 from lkdata.datacube import DataCube, BoolCube, BitwiseCube
-from lkdata.dataframe import DataFrame, BoolFrame, BitwiseFrame
+from lkdata.seriescollection import (
+    DataSeriesCollection,
+    BoolSeriesCollection,
+    BitwiseSeriesCollection,
+)
 from lkdata.dataseries import DataSeries, BoolSeries, BitwiseSeries
 
 
@@ -60,7 +64,7 @@ def datacube(ntime, nrow, ncol):
 @pytest.fixture
 def dataframe(ntime, nrow, ncol):
     """DataFrame"""
-    return DataFrame(
+    return DataSeriesCollection(
         np.random.rand(ntime, nrow * ncol), np.random.rand(ntime, nrow * ncol)
     )
 
@@ -80,7 +84,7 @@ def boolcube(ntime, nrow, ncol):
 @pytest.fixture
 def boolframe(ntime, nrow, ncol):
     """BoolFrame"""
-    return BoolFrame(np.random.choice((True, False), (ntime, nrow * ncol)))
+    return BoolSeriesCollection(np.random.choice((True, False), (ntime, nrow * ncol)))
 
 
 @pytest.fixture
@@ -98,7 +102,7 @@ def bitcube(ntime, nrow, ncol):
 @pytest.fixture
 def bitframe(ntime, nrow, ncol):
     """BitwiseFrame"""
-    return BitwiseFrame(np.random.choice(64, (ntime, nrow * ncol)))
+    return BitwiseSeriesCollection(np.random.choice(64, (ntime, nrow * ncol)))
 
 
 @pytest.fixture
@@ -176,7 +180,7 @@ def test_dataset_init(data_only, sample_dataset, ntime):
 def test_dataset_getitem_string(data_only):
     """Test keyword retreival"""
     assert isinstance(data_only["datacube"], DataCube)
-    assert isinstance(data_only["dataframe"], DataFrame)
+    assert isinstance(data_only["dataframe"], DataSeriesCollection)
     assert isinstance(data_only["dataseries"], DataSeries)
 
 
@@ -191,7 +195,7 @@ def test_dataset_getitem_tuple(data_only):
     """Time and space slice"""
     subset = data_only[1:5, :]
     assert all(
-        isinstance(val, (DataCube, DataFrame, DataSeries))
+        isinstance(val, (DataCube, DataSeriesCollection, DataSeries))
         for val in subset.data_products.values()
     )
 
@@ -213,7 +217,7 @@ def test_dataset_cubes_property(data_only):
 def test_dataset_frames_property(data_only):
     frames = data_only.frames
     assert "dataframe" in frames
-    assert isinstance(frames["dataframe"], DataFrame)
+    assert isinstance(frames["dataframe"], DataSeriesCollection)
 
 
 def test_dataset_series_property(data_only):