zmc
2023-10-12 ed135d79df12a2466b52dae1a82326941211dcc9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
import os
 
import numpy as np
import pytest
 
from pandas.compat import is_platform_little_endian
from pandas.errors import (
    ClosedFileError,
    PossibleDataLossError,
)
 
from pandas import (
    DataFrame,
    HDFStore,
    Series,
    _testing as tm,
    read_hdf,
)
from pandas.tests.io.pytables.common import (
    _maybe_remove,
    ensure_clean_store,
    tables,
)
 
from pandas.io import pytables
from pandas.io.pytables import Term
 
pytestmark = pytest.mark.single_cpu
 
 
@pytest.mark.parametrize("mode", ["r", "r+", "a", "w"])
def test_mode(setup_path, tmp_path, mode):
    df = tm.makeTimeDataFrame()
    msg = r"[\S]* does not exist"
    path = tmp_path / setup_path
 
    # constructor
    if mode in ["r", "r+"]:
        with pytest.raises(OSError, match=msg):
            HDFStore(path, mode=mode)
 
    else:
        with HDFStore(path, mode=mode) as store:
            assert store._handle.mode == mode
 
    path = tmp_path / setup_path
 
    # context
    if mode in ["r", "r+"]:
        with pytest.raises(OSError, match=msg):
            with HDFStore(path, mode=mode) as store:
                pass
    else:
        with HDFStore(path, mode=mode) as store:
            assert store._handle.mode == mode
 
    path = tmp_path / setup_path
 
    # conv write
    if mode in ["r", "r+"]:
        with pytest.raises(OSError, match=msg):
            df.to_hdf(path, "df", mode=mode)
        df.to_hdf(path, "df", mode="w")
    else:
        df.to_hdf(path, "df", mode=mode)
 
    # conv read
    if mode in ["w"]:
        msg = (
            "mode w is not allowed while performing a read. "
            r"Allowed modes are r, r\+ and a."
        )
        with pytest.raises(ValueError, match=msg):
            read_hdf(path, "df", mode=mode)
    else:
        result = read_hdf(path, "df", mode=mode)
        tm.assert_frame_equal(result, df)
 
 
def test_default_mode(tmp_path, setup_path):
    # read_hdf uses default mode
    df = tm.makeTimeDataFrame()
    path = tmp_path / setup_path
    df.to_hdf(path, "df", mode="w")
    result = read_hdf(path, "df")
    tm.assert_frame_equal(result, df)
 
 
def test_reopen_handle(tmp_path, setup_path):
    path = tmp_path / setup_path
 
    store = HDFStore(path, mode="a")
    store["a"] = tm.makeTimeSeries()
 
    msg = (
        r"Re-opening the file \[[\S]*\] with mode \[a\] will delete the "
        "current file!"
    )
    # invalid mode change
    with pytest.raises(PossibleDataLossError, match=msg):
        store.open("w")
 
    store.close()
    assert not store.is_open
 
    # truncation ok here
    store.open("w")
    assert store.is_open
    assert len(store) == 0
    store.close()
    assert not store.is_open
 
    store = HDFStore(path, mode="a")
    store["a"] = tm.makeTimeSeries()
 
    # reopen as read
    store.open("r")
    assert store.is_open
    assert len(store) == 1
    assert store._mode == "r"
    store.close()
    assert not store.is_open
 
    # reopen as append
    store.open("a")
    assert store.is_open
    assert len(store) == 1
    assert store._mode == "a"
    store.close()
    assert not store.is_open
 
    # reopen as append (again)
    store.open("a")
    assert store.is_open
    assert len(store) == 1
    assert store._mode == "a"
    store.close()
    assert not store.is_open
 
 
def test_open_args(setup_path):
    with tm.ensure_clean(setup_path) as path:
        df = tm.makeDataFrame()
 
        # create an in memory store
        store = HDFStore(
            path, mode="a", driver="H5FD_CORE", driver_core_backing_store=0
        )
        store["df"] = df
        store.append("df2", df)
 
        tm.assert_frame_equal(store["df"], df)
        tm.assert_frame_equal(store["df2"], df)
 
        store.close()
 
    # the file should not have actually been written
    assert not os.path.exists(path)
 
 
def test_flush(setup_path):
    with ensure_clean_store(setup_path) as store:
        store["a"] = tm.makeTimeSeries()
        store.flush()
        store.flush(fsync=True)
 
 
def test_complibs_default_settings(tmp_path, setup_path):
    # GH15943
    df = tm.makeDataFrame()
 
    # Set complevel and check if complib is automatically set to
    # default value
    tmpfile = tmp_path / setup_path
    df.to_hdf(tmpfile, "df", complevel=9)
    result = read_hdf(tmpfile, "df")
    tm.assert_frame_equal(result, df)
 
    with tables.open_file(tmpfile, mode="r") as h5file:
        for node in h5file.walk_nodes(where="/df", classname="Leaf"):
            assert node.filters.complevel == 9
            assert node.filters.complib == "zlib"
 
    # Set complib and check to see if compression is disabled
    tmpfile = tmp_path / setup_path
    df.to_hdf(tmpfile, "df", complib="zlib")
    result = read_hdf(tmpfile, "df")
    tm.assert_frame_equal(result, df)
 
    with tables.open_file(tmpfile, mode="r") as h5file:
        for node in h5file.walk_nodes(where="/df", classname="Leaf"):
            assert node.filters.complevel == 0
            assert node.filters.complib is None
 
    # Check if not setting complib or complevel results in no compression
    tmpfile = tmp_path / setup_path
    df.to_hdf(tmpfile, "df")
    result = read_hdf(tmpfile, "df")
    tm.assert_frame_equal(result, df)
 
    with tables.open_file(tmpfile, mode="r") as h5file:
        for node in h5file.walk_nodes(where="/df", classname="Leaf"):
            assert node.filters.complevel == 0
            assert node.filters.complib is None
 
 
def test_complibs_default_settings_override(tmp_path, setup_path):
    # Check if file-defaults can be overridden on a per table basis
    df = tm.makeDataFrame()
    tmpfile = tmp_path / setup_path
    store = HDFStore(tmpfile)
    store.append("dfc", df, complevel=9, complib="blosc")
    store.append("df", df)
    store.close()
 
    with tables.open_file(tmpfile, mode="r") as h5file:
        for node in h5file.walk_nodes(where="/df", classname="Leaf"):
            assert node.filters.complevel == 0
            assert node.filters.complib is None
        for node in h5file.walk_nodes(where="/dfc", classname="Leaf"):
            assert node.filters.complevel == 9
            assert node.filters.complib == "blosc"
 
 
def test_complibs(tmp_path, setup_path):
    # GH14478
    df = tm.makeDataFrame()
 
    # Building list of all complibs and complevels tuples
    all_complibs = tables.filters.all_complibs
    # Remove lzo if its not available on this platform
    if not tables.which_lib_version("lzo"):
        all_complibs.remove("lzo")
    # Remove bzip2 if its not available on this platform
    if not tables.which_lib_version("bzip2"):
        all_complibs.remove("bzip2")
 
    all_levels = range(0, 10)
    all_tests = [(lib, lvl) for lib in all_complibs for lvl in all_levels]
 
    for lib, lvl in all_tests:
        tmpfile = tmp_path / setup_path
        gname = "foo"
 
        # Write and read file to see if data is consistent
        df.to_hdf(tmpfile, gname, complib=lib, complevel=lvl)
        result = read_hdf(tmpfile, gname)
        tm.assert_frame_equal(result, df)
 
        # Open file and check metadata for correct amount of compression
        with tables.open_file(tmpfile, mode="r") as h5table:
            for node in h5table.walk_nodes(where="/" + gname, classname="Leaf"):
                assert node.filters.complevel == lvl
                if lvl == 0:
                    assert node.filters.complib is None
                else:
                    assert node.filters.complib == lib
 
 
@pytest.mark.skipif(
    not is_platform_little_endian(), reason="reason platform is not little endian"
)
def test_encoding(setup_path):
    with ensure_clean_store(setup_path) as store:
        df = DataFrame({"A": "foo", "B": "bar"}, index=range(5))
        df.loc[2, "A"] = np.nan
        df.loc[3, "B"] = np.nan
        _maybe_remove(store, "df")
        store.append("df", df, encoding="ascii")
        tm.assert_frame_equal(store["df"], df)
 
        expected = df.reindex(columns=["A"])
        result = store.select("df", Term("columns=A", encoding="ascii"))
        tm.assert_frame_equal(result, expected)
 
 
@pytest.mark.parametrize(
    "val",
    [
        [b"E\xc9, 17", b"", b"a", b"b", b"c"],
        [b"E\xc9, 17", b"a", b"b", b"c"],
        [b"EE, 17", b"", b"a", b"b", b"c"],
        [b"E\xc9, 17", b"\xf8\xfc", b"a", b"b", b"c"],
        [b"", b"a", b"b", b"c"],
        [b"\xf8\xfc", b"a", b"b", b"c"],
        [b"A\xf8\xfc", b"", b"a", b"b", b"c"],
        [np.nan, b"", b"b", b"c"],
        [b"A\xf8\xfc", np.nan, b"", b"b", b"c"],
    ],
)
@pytest.mark.parametrize("dtype", ["category", object])
def test_latin_encoding(tmp_path, setup_path, dtype, val):
    enc = "latin-1"
    nan_rep = ""
    key = "data"
 
    val = [x.decode(enc) if isinstance(x, bytes) else x for x in val]
    ser = Series(val, dtype=dtype)
 
    store = tmp_path / setup_path
    ser.to_hdf(store, key, format="table", encoding=enc, nan_rep=nan_rep)
    retr = read_hdf(store, key)
 
    s_nan = ser.replace(nan_rep, np.nan)
 
    tm.assert_series_equal(s_nan, retr)
 
 
def test_multiple_open_close(tmp_path, setup_path):
    # gh-4409: open & close multiple times
 
    path = tmp_path / setup_path
 
    df = tm.makeDataFrame()
    df.to_hdf(path, "df", mode="w", format="table")
 
    # single
    store = HDFStore(path)
    assert "CLOSED" not in store.info()
    assert store.is_open
 
    store.close()
    assert "CLOSED" in store.info()
    assert not store.is_open
 
    path = tmp_path / setup_path
 
    if pytables._table_file_open_policy_is_strict:
        # multiples
        store1 = HDFStore(path)
        msg = (
            r"The file [\S]* is already opened\.  Please close it before "
            r"reopening in write mode\."
        )
        with pytest.raises(ValueError, match=msg):
            HDFStore(path)
 
        store1.close()
    else:
        # multiples
        store1 = HDFStore(path)
        store2 = HDFStore(path)
 
        assert "CLOSED" not in store1.info()
        assert "CLOSED" not in store2.info()
        assert store1.is_open
        assert store2.is_open
 
        store1.close()
        assert "CLOSED" in store1.info()
        assert not store1.is_open
        assert "CLOSED" not in store2.info()
        assert store2.is_open
 
        store2.close()
        assert "CLOSED" in store1.info()
        assert "CLOSED" in store2.info()
        assert not store1.is_open
        assert not store2.is_open
 
        # nested close
        store = HDFStore(path, mode="w")
        store.append("df", df)
 
        store2 = HDFStore(path)
        store2.append("df2", df)
        store2.close()
        assert "CLOSED" in store2.info()
        assert not store2.is_open
 
        store.close()
        assert "CLOSED" in store.info()
        assert not store.is_open
 
        # double closing
        store = HDFStore(path, mode="w")
        store.append("df", df)
 
        store2 = HDFStore(path)
        store.close()
        assert "CLOSED" in store.info()
        assert not store.is_open
 
        store2.close()
        assert "CLOSED" in store2.info()
        assert not store2.is_open
 
    # ops on a closed store
    path = tmp_path / setup_path
 
    df = tm.makeDataFrame()
    df.to_hdf(path, "df", mode="w", format="table")
 
    store = HDFStore(path)
    store.close()
 
    msg = r"[\S]* file is not open!"
    with pytest.raises(ClosedFileError, match=msg):
        store.keys()
 
    with pytest.raises(ClosedFileError, match=msg):
        "df" in store
 
    with pytest.raises(ClosedFileError, match=msg):
        len(store)
 
    with pytest.raises(ClosedFileError, match=msg):
        store["df"]
 
    with pytest.raises(ClosedFileError, match=msg):
        store.select("df")
 
    with pytest.raises(ClosedFileError, match=msg):
        store.get("df")
 
    with pytest.raises(ClosedFileError, match=msg):
        store.append("df2", df)
 
    with pytest.raises(ClosedFileError, match=msg):
        store.put("df3", df)
 
    with pytest.raises(ClosedFileError, match=msg):
        store.get_storer("df2")
 
    with pytest.raises(ClosedFileError, match=msg):
        store.remove("df2")
 
    with pytest.raises(ClosedFileError, match=msg):
        store.select("df")
 
    msg = "'HDFStore' object has no attribute 'df'"
    with pytest.raises(AttributeError, match=msg):
        store.df
 
 
def test_fspath():
    with tm.ensure_clean("foo.h5") as path:
        with HDFStore(path) as store:
            assert os.fspath(store) == str(path)