def __init__(
self: Column[T],
name: str,
data: Optional[list[T]] = None,
index: Optional[list] = None,
dtype: Optional[T] = None,
) -> None:
self.name = name
if data is not None:
if issubclass(type(data), DataBackend):
self._data_backend = data
else:
self._data_backend = PandasBackend({name: data}, index=index)
self.dtype = (
self.infer_dtype(self.name, self._data_backend)
if dtype is None
else DataType(dtype)
)
else:
self._data_backend = PandasBackend(index=index)
self.dtype = Object
if data is not None:
self._validate_column()
self.loc = Column._LocIndexer[T](self)
self.iloc = Column._ILocIndexer[T](self)
def test_lt(self) -> None:
expected = PandasBackend({"a": ["a"], "b": [1], "c": [True]})
query = self.data_backend["b"] < 2
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
test = PandasBackend({"b": [2]})
query = self.data_backend < test
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
def test_equals(self) -> None:
test = PandasBackend(
{"a": ["a", "b", "c"], "b": [1, 2, 3], "c": [True, False, True]}
)
assert_that(self.data_backend.equals(test), equal_to(True))
test = PandasBackend(
{"a": ["a", "b", "d"], "b": [1, 2, 3], "c": [True, False, True]}
)
assert_that(self.data_backend.equals(test), equal_to(False))
def test_concat(self) -> None:
postfix = PandasBackend({"a": ["d"], "b": [4], "c": [False]})
new_frame = PandasBackend.concat([self.data_backend, postfix], ignore_index=True)
expected = PandasBackend(
{
"a": ["a", "b", "c", "d"],
"b": [1, 2, 3, 4],
"c": [True, False, True, False],
}
)
assert_that(new_frame.equals(expected), equal_to(True))
def __init__(
self: T,
metadata: Optional[M] = None,
index: Optional[Iterable] = None,
**column_data: dict[str, list],
) -> None:
self.metadata = metadata
if len(column_data) > 0:
column_data = {str(name): col for name, col in column_data.items()}
self._data_backend = PandasBackend(column_data, index=index)
self._validate_data_frame()
else:
self._data_backend = PandasBackend(index=index)
self._compile()
def test_ge(self) -> None:
expected = PandasBackend({
"a": ["b", "c"],
"b": [2, 3],
"c": [False, True]
})
query = self.data_backend["b"] >= 2
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
test = PandasBackend({"b": [2]})
query = self.data_backend >= test
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
def test_eq(self) -> None:
expected = PandasBackend({"a": ["a"], "b": [1], "c": [True]})
query = self.data_backend["a"] == "a"
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
test = PandasBackend({"a": ["a", "c"], "b": [1, 3]})
expected = PandasBackend({
"a": ["a", "c"],
"b": [1, 3],
"c": [True, True]
})
query = self.data_backend == test
queried = self.data_backend.query(query)
assert_that(queried.equals(expected), equal_to(True))
def test_drop_indices(self) -> None:
new_frame = self.data_backend.drop_indices([1])
expected = PandasBackend(
{"a": ["a", "c"], "b": [1, 3], "c": [True, True]},
index=PandasIndex(PIndex([0, 2], name="index"), []),
)
assert_that(new_frame.equals(expected), equal_to(True))
def test_query(self) -> None:
query = (ExampleStore.a == "a") | (ExampleStore.b == 3)
test = self.data_backend.query(query)
expected = PandasBackend(
{"a": ["a", "c"], "b": [1, 3], "c": [True, True]},
index=PandasIndex(PIndex([0, 2], name="index"), []),
)
assert_that(test.equals(expected), equal_to(True))
def test_getmask(self) -> None:
test = self.data_backend.getmask([True, False, True])
expected = PandasBackend(
{"a": ["a", "c"], "b": [1, 3], "c": [True, True]},
index=PandasIndex(PIndex([0, 2], name="index"), []),
)
repr(expected)
assert_that(test.equals(expected), equal_to(True))
def from_rows(
cls: Type[T],
data_rows: list[tuple],
columns: Optional[list[str]] = None,
metadata: Optional[M] = None,
) -> T:
if columns is None:
columns = list(cls._parse_columns().keys())
else:
columns = [str(col) for col in columns]
data = DataFrame.from_records(data_rows, columns=columns)
return cls.from_backend(PandasBackend(data), metadata)
def test_ne(self) -> None:
test = PandasBackend(
{"a": ["d", "b", "c"], "b": [1, 4, 3], "c": [True, False, False]}
)
expected = DataFrame(
{
"a": [True, False, False],
"b": [False, True, False],
"c": [False, False, True],
}
)
assert_that((self.data_backend != test).equals(expected), equal_to(True))
def test_append(self) -> None:
try:
postfix = PandasBackend({"a": ["d"], "b": [4], "c": [False]})
self.data_backend.append(postfix, ignore_index=True)
fail("Expected exception")
except NotImplementedError as e:
assert_that(
str(e),
equal_to(
"The current version of Tanuki does not support Store to DB writing"
),
)
def setup_method(self) -> None:
self.test_store = ExampleStore(a=["a", "b", "c"],
b=[1, 2, 3],
c=[True, False, True])
conn_config = self.sql_db.connection_config()
self.db = Sqlite3Database(conn_config)
self.db.insert(ExampleStore.data_token, self.test_store)
self.db_store = ExampleStore.link(self.db, ExampleStore.data_token)
self.data_backend = self.db_store._data_backend
self.test_series0 = PandasBackend(Series({
"a": "a",
"b": 1,
"c": True
}),
index=[0])
self.test_series2 = PandasBackend(Series({
"a": "c",
"b": 3,
"c": True
}),
index=[2])
def test_equals(self) -> None:
test = DatabaseBackend(ExampleStore, self.db, ExampleStore.data_token)
assert_that(self.data_backend.equals(test), equal_to(True))
newBackend = self.data_backend[ExampleStore.a]
test = DatabaseBackend(ExampleStore, self.db, ExampleStore.data_token)
assert_that(newBackend.equals(test), equal_to(False))
test = DatabaseBackend(ExampleStore, self.db, ExampleStore.data_token,
None, ["a"])
assert_that(self.data_backend.equals(test[ExampleStore.a]),
equal_to(False))
test = PandasBackend({
"a": ["a", "b", "d"],
"b": [1, 2, 3],
"c": [True, False, True]
})
assert_that(self.data_backend.equals(test), equal_to(False))
def from_pandas(cls: Type[T],
data: Union[Series, DataFrame],
metadata: Optional[M] = None) -> T:
return cls.from_backend(PandasBackend(data), metadata)
def test_getitem(self) -> None:
expected = PandasBackend({"b": [1, 2, 3]})
assert_that(self.data_backend["b"].equals(expected), equal_to(True))
def setup_method(self) -> None:
self.data_backend = PandasBackend(
DataFrame({"a": ["a", "b", "c"], "b": [1, 2, 3], "c": [True, False, True]})
)
self.test_series0 = PandasBackend(Series({"a": "a", "b": 1, "c": True}), index=[0])
self.test_series2 = PandasBackend(Series({"a": "c", "b": 3, "c": True}), index=[2])
def test_getitems(self) -> None:
expected = PandasBackend({"a": ["a", "b", "c"], "b": [1, 2, 3]})
assert_that(
self.data_backend.getitems(["a", "b"]).equals(expected), equal_to(True)
)
def test_setitem(self) -> None:
self.data_backend["a"] = ["d", "e", "f"]
expected = PandasBackend(
{"a": ["d", "e", "f"], "b": [1, 2, 3], "c": [True, False, True]}
)
assert_that(self.data_backend.equals(expected), equal_to(True))
