maxframe 0.1.0b5__cp310-cp310-macosx_11_0_arm64.whl

maxframe/odpsio/tests/test_arrow.py

@@ -0,0 +1,88 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+
+from ..arrow import arrow_to_pandas, pandas_to_arrow
+
+
+def test_dataframe_convert():
+    pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("ABCDE"))
+    arrow_data, meta = pandas_to_arrow(pd_data)
+    assert arrow_data.column_names == ["_idx_0", "a", "b", "c", "d", "e"]
+
+    pd.testing.assert_index_equal(pd.Index(arrow_data.columns[0]), pd_data.index)
+    pd.testing.assert_frame_equal(
+        arrow_data.select(list("abcde")).to_pandas().set_axis(list("ABCDE"), axis=1),
+        pd_data.reset_index(drop=True),
+    )
+
+    pd_res = arrow_to_pandas(arrow_data, meta)
+    pd.testing.assert_frame_equal(pd_data, pd_res)
+
+    # test DataFrame with MultiIndex as columns
+    pd_data.columns = pd.MultiIndex.from_tuples(
+        [("A", "A"), ("A", "B"), ("B", "A"), ("B", "B"), ("B", "C")]
+    )
+    arrow_data, meta = pandas_to_arrow(pd_data)
+    pd_res = arrow_to_pandas(arrow_data, meta)
+    pd.testing.assert_frame_equal(pd_data, pd_res)
+
+
+def test_series_convert():
+    pd_data = pd.Series(np.random.rand(100), name="series_name")
+    arrow_data, meta = pandas_to_arrow(pd_data)
+    assert arrow_data.column_names == ["_idx_0", "series_name"]
+
+    pd.testing.assert_index_equal(pd.Index(arrow_data.columns[0]), pd_data.index)
+    pd.testing.assert_series_equal(
+        arrow_data.select(["series_name"]).to_pandas().iloc[:, 0],
+        pd_data.reset_index(drop=True),
+    )
+
+    pd_res = arrow_to_pandas(arrow_data, meta)
+    pd.testing.assert_series_equal(pd_data, pd_res)
+
+
+def test_index_convert():
+    pd_data = pd.Index(np.random.rand(100), name="idx_name")
+    arrow_data, meta = pandas_to_arrow(pd_data)
+    assert arrow_data.column_names == ["_idx_0"]
+
+    pd.testing.assert_index_equal(
+        pd.Index(arrow_data.columns[0], name="idx_name"), pd_data
+    )
+
+    pd_res = arrow_to_pandas(arrow_data, meta)
+    pd.testing.assert_index_equal(pd_data, pd_res)
+
+    # test MultiIndex
+    pd_data = pd.MultiIndex.from_arrays(
+        [np.random.choice(list("ABC"), 100), np.random.randint(0, 10, 100)]
+    )
+    arrow_data, meta = pandas_to_arrow(pd_data)
+    pd_res = arrow_to_pandas(arrow_data, meta)
+    pd.testing.assert_index_equal(pd_data, pd_res)
+
+
+def test_scalar_convert():
+    scalar_data = 12.3456
+    arrow_data, meta = pandas_to_arrow(scalar_data)
+    assert arrow_data.column_names == ["_idx_0"]
+
+    assert arrow_data[0][0].as_py() == scalar_data
+
+    scalar_res = arrow_to_pandas(arrow_data, meta)
+    assert scalar_data == scalar_res

maxframe/odpsio/tests/test_schema.py

@@ -0,0 +1,297 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+import pytest
+from odps import types as odps_types
+
+from ... import dataframe as md
+from ... import tensor as mt
+from ...core import OutputType
+from ..schema import (
+    arrow_schema_to_odps_schema,
+    build_dataframe_table_meta,
+    build_table_column_name,
+    odps_schema_to_arrow_schema,
+    pandas_to_odps_schema,
+)
+
+
+def _wrap_maxframe_obj(obj, wrap="no"):
+    if wrap == "no":
+        return obj
+    if isinstance(obj, pd.DataFrame):
+        obj = md.DataFrame(obj)
+    elif isinstance(obj, pd.Series):
+        obj = md.Series(obj)
+    elif isinstance(obj, pd.Index):
+        obj = md.Index(obj)
+    else:
+        obj = mt.scalar(obj)
+    if wrap == "data":
+        return obj.data
+    return obj
+
+
+@pytest.mark.parametrize("wrap_obj", ["no", "yes", "data"])
+def test_pandas_to_odps_schema_dataframe(wrap_obj):
+    data = pd.DataFrame(np.random.rand(100, 5), columns=list("ABCDE"))
+
+    test_df = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_df)
+    assert [c.name for c in schema.columns] == ["_idx_0"] + list(
+        test_df.dtypes.index.str.lower()
+    )
+    assert [c.type.name for c in schema.columns] == ["bigint"] + ["double"] * len(
+        test_df.columns
+    )
+    assert meta.type == OutputType.dataframe
+    assert meta.table_column_names == list(test_df.dtypes.index.str.lower())
+    assert meta.table_index_column_names == ["_idx_0"]
+    assert meta.pd_column_level_names == [None]
+    assert meta.pd_index_level_names == [None]
+
+    test_df = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_df, ignore_index=True)
+    assert [c.name for c in schema.columns] == list(test_df.dtypes.index.str.lower())
+    assert [c.type.name for c in schema.columns] == ["double"] * len(test_df.columns)
+    assert meta.type == OutputType.dataframe
+    assert meta.table_column_names == list(test_df.dtypes.index.str.lower())
+    assert meta.table_index_column_names == []
+    assert meta.pd_column_level_names == [None]
+    assert meta.pd_index_level_names == []
+
+    data.columns = pd.MultiIndex.from_tuples(
+        [("A", "A"), ("A", "B"), ("A", "C"), ("B", "A"), ("B", "B")], names=["c1", "c2"]
+    )
+    data.index = pd.MultiIndex.from_arrays(
+        [np.random.choice(list("ABC"), 100), np.random.randint(0, 10, 100)]
+    )
+    test_df = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_df, unknown_as_string=True)
+    assert [c.name for c in schema.columns] == ["_idx_0", "_idx_1"] + list(
+        test_df.dtypes.index.map("_".join).str.lower()
+    )
+    assert [c.type.name for c in schema.columns] == ["string", "bigint"] + [
+        "double"
+    ] * len(test_df.columns)
+    assert meta.type == OutputType.dataframe
+    assert meta.table_column_names == list(
+        test_df.dtypes.index.map("_".join).str.lower()
+    )
+    assert meta.table_index_column_names == ["_idx_0", "_idx_1"]
+    assert meta.pd_column_level_names == ["c1", "c2"]
+    assert meta.pd_index_level_names == [None, None]
+
+
+@pytest.mark.parametrize("wrap_obj", ["no", "yes", "data"])
+def test_pandas_to_odps_schema_series(wrap_obj):
+    data = pd.Series(np.random.rand(100))
+
+    test_s = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_s)
+    assert [c.name for c in schema.columns] == ["_idx_0", "_data"]
+    assert [c.type.name for c in schema.columns] == ["bigint", "double"]
+    assert meta.type == OutputType.series
+    assert meta.table_column_names == ["_data"]
+    assert meta.table_index_column_names == ["_idx_0"]
+    assert meta.pd_column_names == [None]
+    assert meta.pd_column_level_names == [None]
+    assert meta.pd_index_level_names == [None]
+
+    schema, meta = pandas_to_odps_schema(test_s, ignore_index=True)
+    assert [c.name for c in schema.columns] == ["_data"]
+    assert [c.type.name for c in schema.columns] == ["double"]
+    assert meta.type == OutputType.series
+    assert meta.table_column_names == ["_data"]
+    assert meta.table_index_column_names == []
+    assert meta.pd_column_level_names == [None]
+    assert meta.pd_index_level_names == []
+
+    data.index = pd.MultiIndex.from_arrays(
+        [np.random.choice(list("ABC"), 100), np.random.randint(0, 10, 100)],
+        names=["c1", "c2"],
+    )
+    data.name = "col_name"
+    test_s = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_s, unknown_as_string=True)
+    assert [c.name for c in schema.columns] == ["_idx_0", "_idx_1", "col_name"]
+    assert [c.type.name for c in schema.columns] == ["string", "bigint", "double"]
+    assert meta.type == OutputType.series
+    assert meta.table_column_names == ["col_name"]
+    assert meta.table_index_column_names == ["_idx_0", "_idx_1"]
+    assert meta.pd_column_names == ["col_name"]
+    assert meta.pd_column_level_names == [None]
+    assert meta.pd_index_level_names == ["c1", "c2"]
+
+
+@pytest.mark.parametrize("wrap_obj", ["no", "yes", "data"])
+def test_pandas_to_odps_schema_index(wrap_obj):
+    data = pd.Index(np.random.randint(0, 100, 100))
+
+    test_idx = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_idx, unknown_as_string=True)
+    assert [c.name for c in schema.columns] == ["_idx_0"]
+    assert [c.type.name for c in schema.columns] == ["bigint"]
+    assert meta.type == OutputType.index
+    assert meta.table_column_names == []
+    assert meta.table_index_column_names == ["_idx_0"]
+    assert meta.pd_column_level_names == []
+    assert meta.pd_index_level_names == [None]
+
+    with pytest.raises(AssertionError):
+        pandas_to_odps_schema(test_idx, unknown_as_string=True, ignore_index=True)
+
+    data = pd.MultiIndex.from_arrays(
+        [np.random.choice(list("ABC"), 100), np.random.randint(0, 10, 100)],
+        names=["c1", "c2"],
+    )
+    test_idx = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    schema, meta = pandas_to_odps_schema(test_idx, unknown_as_string=True)
+    assert [c.name for c in schema.columns] == ["_idx_0", "_idx_1"]
+    assert [c.type.name for c in schema.columns] == ["string", "bigint"]
+    assert meta.type == OutputType.index
+    assert meta.table_column_names == []
+    assert meta.table_index_column_names == ["_idx_0", "_idx_1"]
+    assert meta.pd_column_level_names == []
+    assert meta.pd_index_level_names == ["c1", "c2"]
+
+
+@pytest.mark.parametrize("wrap_obj", ["no", "yes", "data"])
+def test_pandas_to_odps_schema_scalar(wrap_obj):
+    data = 1234.56
+
+    test_scalar = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    if wrap_obj != "no":
+        test_scalar.op.data = None
+    schema, meta = pandas_to_odps_schema(test_scalar, unknown_as_string=True)
+    assert schema.columns[0].name == "_idx_0"
+    assert schema.columns[0].type.name == "double"
+    assert meta.type == OutputType.scalar
+    assert meta.table_column_names == []
+    assert meta.table_index_column_names == ["_idx_0"]
+    assert meta.pd_column_level_names == []
+    assert meta.pd_index_level_names == [None]
+
+    with pytest.raises(AssertionError):
+        pandas_to_odps_schema(test_scalar, unknown_as_string=True, ignore_index=True)
+
+
+def test_odps_arrow_schema_conversion():
+    odps_schema = odps_types.OdpsSchema(
+        [
+            odps_types.Column("col1", "string"),
+            odps_types.Column("col2", "binary"),
+            odps_types.Column("col3", "tinyint"),
+            odps_types.Column("col4", "smallint"),
+            odps_types.Column("col5", "int"),
+            odps_types.Column("col6", "bigint"),
+            odps_types.Column("col7", "boolean"),
+            odps_types.Column("col8", "float"),
+            odps_types.Column("col9", "double"),
+            odps_types.Column("col10", "date"),
+            odps_types.Column("col11", "datetime"),
+            odps_types.Column("col12", "timestamp"),
+            odps_types.Column("col13", "decimal(10, 2)"),
+            odps_types.Column("col14", "array<string>"),
+            odps_types.Column("col15", "map<string, bigint>"),
+            odps_types.Column("col16", "struct<a1: string, a2: map<string, bigint>>"),
+            odps_types.Column("col17", "CHAR(15)"),
+            odps_types.Column("col18", "VARCHAR(15)"),
+        ]
+    )
+    arrow_schema = odps_schema_to_arrow_schema(odps_schema)
+    assert arrow_schema.names == [f"col{i}" for i in range(1, 19)]
+    assert arrow_schema.types == [
+        pa.string(),
+        pa.binary(),
+        pa.int8(),
+        pa.int16(),
+        pa.int32(),
+        pa.int64(),
+        pa.bool_(),
+        pa.float32(),
+        pa.float64(),
+        pa.date32(),
+        pa.timestamp("ms"),
+        pa.timestamp("ns"),
+        pa.decimal128(10, 2),
+        pa.list_(pa.string()),
+        pa.map_(pa.string(), pa.int64()),
+        pa.struct([("a1", pa.string()), ("a2", pa.map_(pa.string(), pa.int64()))]),
+        pa.string(),
+        pa.string(),
+    ]
+
+    expected_odps_schema = odps_types.OdpsSchema(
+        [
+            odps_types.Column("col1", "string"),
+            odps_types.Column("col2", "binary"),
+            odps_types.Column("col3", "tinyint"),
+            odps_types.Column("col4", "smallint"),
+            odps_types.Column("col5", "int"),
+            odps_types.Column("col6", "bigint"),
+            odps_types.Column("col7", "boolean"),
+            odps_types.Column("col8", "float"),
+            odps_types.Column("col9", "double"),
+            odps_types.Column("col10", "date"),
+            odps_types.Column("col11", "datetime"),
+            odps_types.Column("col12", "timestamp"),
+            odps_types.Column("col13", "decimal(10, 2)"),
+            odps_types.Column("col14", "array<string>"),
+            odps_types.Column("col15", "map<string, bigint>"),
+            odps_types.Column("col16", "struct<a1: string, a2: map<string, bigint>>"),
+            odps_types.Column("col17", "string"),
+            odps_types.Column("col18", "string"),
+        ]
+    )
+
+    odps_schema2 = arrow_schema_to_odps_schema(arrow_schema)
+    assert [c.name for c in expected_odps_schema.columns] == [
+        c.name for c in odps_schema2.columns
+    ]
+    assert [c.type for c in expected_odps_schema.columns] == [
+        c.type for c in odps_schema2.columns
+    ]
+
+    with pytest.raises(TypeError):
+        arrow_schema_to_odps_schema(pa.schema([("col1", pa.float16())]))
+    with pytest.raises(TypeError):
+        odps_schema_to_arrow_schema(
+            odps_types.OdpsSchema([odps_types.Column("col1", "json")])
+        )
+
+
+def test_build_column_name():
+    records = dict()
+    assert build_table_column_name(0, "a" * 127, records) == "a" * 127
+    assert build_table_column_name(1, "_abc123", records) == "_abc123"
+    assert build_table_column_name(2, "_abc'123", records) == "_column_2"
+    assert build_table_column_name(3, "a" * 256, records) == "_column_3"
+    assert build_table_column_name(4, ("A", 1), records) == "a_1"
+
+
+@pytest.mark.parametrize("wrap_obj", ["no", "yes", "data"])
+def test_build_table_meta(wrap_obj):
+    data = pd.DataFrame(
+        np.random.rand(100, 7),
+        columns=["A", "A", "A_0", "A_1", "a_1", "B", "C"],
+    )
+
+    test_df = _wrap_maxframe_obj(data, wrap=wrap_obj)
+    table_meta = build_dataframe_table_meta(test_df)
+    expected_cols = ["a_2", "a_3", "a_0", "a_1_0", "a_1_1", "b", "c"]
+    assert table_meta.table_column_names == expected_cols

maxframe/odpsio/tests/test_tableio.py

@@ -0,0 +1,136 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from odps import ODPS
+
+from ...tests.utils import flaky, tn
+from ...utils import config_odps_default_options
+from ..tableio import HaloTableIO
+
+
+@flaky(max_runs=3)
+def test_empty_table_io():
+    config_odps_default_options()
+
+    o = ODPS.from_environments()
+    halo_table_io = HaloTableIO(o)
+
+    # test read from empty table
+    empty_table_name = tn("test_empty_table_halo_read")
+    o.delete_table(empty_table_name, if_exists=True)
+    tb = o.create_table(empty_table_name, "col1 string", lifecycle=1)
+
+    try:
+        with halo_table_io.open_reader(empty_table_name) as reader:
+            assert len(reader.read_all()) == 0
+    finally:
+        tb.drop()
+
+
+@flaky(max_runs=3)
+def test_table_io_without_parts():
+    config_odps_default_options()
+
+    o = ODPS.from_environments()
+    halo_table_io = HaloTableIO(o)
+
+    # test read and write tables without partition
+    no_part_table_name = tn("test_no_part_halo_write")
+    o.delete_table(no_part_table_name, if_exists=True)
+    tb = o.create_table(
+        no_part_table_name, ",".join(f"{c} double" for c in "abcde"), lifecycle=1
+    )
+
+    try:
+        pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("abcde"))
+        with halo_table_io.open_writer(no_part_table_name) as writer:
+            writer.write(pa.Table.from_pandas(pd_data, preserve_index=False))
+        with halo_table_io.open_reader(no_part_table_name) as reader:
+            pd.testing.assert_frame_equal(reader.read_all().to_pandas(), pd_data)
+    finally:
+        tb.drop()
+
+
+@flaky(max_runs=3)
+def test_table_io_with_range_reader():
+    config_odps_default_options()
+
+    o = ODPS.from_environments()
+    halo_table_io = HaloTableIO(o)
+
+    # test read and write tables without partition
+    no_part_table_name = tn("test_no_part_halo_write")
+    o.delete_table(no_part_table_name, if_exists=True)
+    tb = o.create_table(
+        no_part_table_name, ",".join(f"{c} double" for c in "abcde"), lifecycle=1
+    )
+
+    try:
+        pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("abcde"))
+        with halo_table_io.open_writer(no_part_table_name) as writer:
+            writer.write(pa.Table.from_pandas(pd_data, preserve_index=False))
+
+        with halo_table_io.open_reader(
+            no_part_table_name, start=None, stop=100, row_batch_size=10
+        ) as reader:
+            pd.testing.assert_frame_equal(reader.read_all().to_pandas(), pd_data)
+
+        with halo_table_io.open_reader(
+            no_part_table_name,
+            start=-2,
+            stop=-52,
+            reverse_range=True,
+            row_batch_size=10,
+        ) as reader:
+            pd.testing.assert_frame_equal(
+                reader.read_all().to_pandas(),
+                pd_data.iloc[-51:-1].reset_index(drop=True),
+            )
+    finally:
+        tb.drop()
+
+
+@flaky(max_runs=3)
+def test_table_io_with_parts():
+    config_odps_default_options()
+
+    o = ODPS.from_environments()
+    halo_table_io = HaloTableIO(o)
+
+    # test read and write tables with partition
+    parted_table_name = tn("test_parted_halo_write")
+    o.delete_table(parted_table_name, if_exists=True)
+    tb = o.create_table(
+        parted_table_name,
+        (",".join(f"{c} double" for c in "abcde"), "pt string"),
+        lifecycle=1,
+    )
+
+    try:
+        pd_data = pd.DataFrame(np.random.rand(100, 5), columns=list("abcde"))
+        with halo_table_io.open_writer(parted_table_name, "pt=test") as writer:
+            writer.write(pa.Table.from_pandas(pd_data, preserve_index=False))
+        with halo_table_io.open_reader(parted_table_name, "pt=test") as reader:
+            pd.testing.assert_frame_equal(reader.read_all().to_pandas(), pd_data)
+        with halo_table_io.open_reader(
+            parted_table_name, "pt=test", partition_columns=True
+        ) as reader:
+            expected_data = pd_data.copy()
+            expected_data["pt"] = "test"
+            pd.testing.assert_frame_equal(reader.read_all().to_pandas(), expected_data)
+    finally:
+        tb.drop()

maxframe/odpsio/tests/test_volumeio.py

@@ -0,0 +1,90 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+from odps import ODPS
+
+from ...tests.utils import tn
+from ..volumeio import ODPSVolumeReader, ODPSVolumeWriter
+
+
+@pytest.fixture
+def create_volume(request, oss_config):
+    test_vol_name = tn("test_vol_name_" + request.param)
+    odps_entry = ODPS.from_environments()
+
+    try:
+        odps_entry.delete_volume(test_vol_name)
+    except:
+        pass
+
+    oss_test_dir_name = None
+    if request.param == "parted":
+        odps_entry.create_parted_volume(test_vol_name)
+    else:
+        oss_test_dir_name = tn("test_oss_directory")
+        if oss_config is None:
+            pytest.skip("Need oss and its config to run this test")
+        (
+            oss_access_id,
+            oss_secret_access_key,
+            oss_bucket_name,
+            oss_endpoint,
+        ) = oss_config.oss_config
+        test_location = "oss://%s:%s@%s/%s/%s" % (
+            oss_access_id,
+            oss_secret_access_key,
+            oss_endpoint,
+            oss_bucket_name,
+            oss_test_dir_name,
+        )
+        oss_config.oss_bucket.put_object(oss_test_dir_name + "/", b"")
+        odps_entry.create_external_volume(test_vol_name, location=test_location)
+    try:
+        yield test_vol_name
+    finally:
+        try:
+            odps_entry.delete_volume(test_vol_name)
+        except BaseException:
+            pass
+
+        if oss_test_dir_name is not None:
+            import oss2
+
+            keys = [
+                obj.key
+                for obj in oss2.ObjectIterator(oss_config.oss_bucket, oss_test_dir_name)
+            ]
+            oss_config.oss_bucket.batch_delete_objects(keys)
+
+
+@pytest.mark.parametrize("create_volume", ["parted", "external"], indirect=True)
+def test_read_write_volume(create_volume):
+    test_vol_dir = "test_vol_dir"
+
+    odps_entry = ODPS.from_environments()
+
+    writer = ODPSVolumeWriter(odps_entry, create_volume, test_vol_dir)
+    write_session_id = writer.create_write_session()
+
+    writer = ODPSVolumeWriter(odps_entry, create_volume, test_vol_dir)
+    writer.write_file("file1", b"content1", write_session_id)
+    writer.write_file("file2", b"content2", write_session_id)
+    writer.commit(["file1", "file2"], write_session_id)
+
+    reader = ODPSVolumeReader(odps_entry, create_volume, test_vol_dir)
+    assert reader.read_file("file1") == b"content1"
+    assert reader.read_file("file2") == b"content2"
+
+    assert ["file1", "file2"] == sorted(reader.list_files())