-
Notifications
You must be signed in to change notification settings - Fork 524
/
h5p.pyx
2003 lines (1493 loc) · 57.2 KB
/
h5p.pyx
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
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# cython: language_level=3
# This file is part of h5py, a Python interface to the HDF5 library.
#
# http://www.h5py.org
#
# Copyright 2008-2013 Andrew Collette and contributors
#
# License: Standard 3-clause BSD; see "license.txt" for full license terms
# and contributor agreement.
"""
HDF5 property list interface.
"""
include "config.pxi"
# C-level imports
from cpython.buffer cimport PyObject_CheckBuffer, \
PyObject_GetBuffer, PyBuffer_Release, \
PyBUF_SIMPLE
from cpython.long cimport PyLong_AsVoidPtr
from .utils cimport require_tuple, convert_dims, convert_tuple, \
emalloc, efree, \
check_numpy_write, check_numpy_read
from numpy cimport ndarray, import_array
from .h5t cimport TypeID, py_create
from .h5s cimport SpaceID
from .h5ac cimport CacheConfig
# Python level imports
from ._objects import phil, with_phil
if MPI:
from mpi4py.libmpi cimport (
MPI_Comm, MPI_Info, MPI_Comm_dup, MPI_Info_dup,
MPI_Comm_free, MPI_Info_free)
# Initialization
import_array()
# === C API ===================================================================
cdef hid_t pdefault(PropID pid):
if pid is None:
return <hid_t>H5P_DEFAULT
return pid.id
cdef object propwrap(hid_t id_in):
clsid = H5Pget_class(id_in)
try:
if H5Pequal(clsid, H5P_FILE_CREATE):
pcls = PropFCID
elif H5Pequal(clsid, H5P_FILE_ACCESS):
pcls = PropFAID
elif H5Pequal(clsid, H5P_DATASET_CREATE):
pcls = PropDCID
elif H5Pequal(clsid, H5P_DATASET_XFER):
pcls = PropDXID
elif H5Pequal(clsid, H5P_OBJECT_COPY):
pcls = PropCopyID
elif H5Pequal(clsid, H5P_LINK_CREATE):
pcls = PropLCID
elif H5Pequal(clsid, H5P_LINK_ACCESS):
pcls = PropLAID
elif H5Pequal(clsid, H5P_GROUP_CREATE):
pcls = PropGCID
elif H5Pequal(clsid, H5P_DATATYPE_CREATE):
pcls = PropTCID
elif H5Pequal(clsid, H5P_DATASET_ACCESS):
pcls = PropDAID
elif H5Pequal(clsid, H5P_OBJECT_CREATE):
pcls = PropOCID
else:
raise ValueError("No class found for ID %d" % id_in)
return pcls(id_in)
finally:
H5Pclose_class(clsid)
cdef object lockcls(hid_t id_in):
cdef PropClassID pid
pid = PropClassID(id_in)
pid.locked = 1
return pid
# === Public constants and data structures ====================================
# Property list classes
# These need to be locked, as the library won't let you close them.
NO_CLASS = lockcls(H5P_NO_CLASS)
FILE_CREATE = lockcls(H5P_FILE_CREATE)
FILE_ACCESS = lockcls(H5P_FILE_ACCESS)
DATASET_CREATE = lockcls(H5P_DATASET_CREATE)
DATASET_XFER = lockcls(H5P_DATASET_XFER)
DATASET_ACCESS = lockcls(H5P_DATASET_ACCESS)
OBJECT_COPY = lockcls(H5P_OBJECT_COPY)
LINK_CREATE = lockcls(H5P_LINK_CREATE)
LINK_ACCESS = lockcls(H5P_LINK_ACCESS)
GROUP_CREATE = lockcls(H5P_GROUP_CREATE)
OBJECT_CREATE = lockcls(H5P_OBJECT_CREATE)
CRT_ORDER_TRACKED = H5P_CRT_ORDER_TRACKED
CRT_ORDER_INDEXED = H5P_CRT_ORDER_INDEXED
DEFAULT = None # In the HDF5 header files this is actually 0, which is an
# invalid identifier. The new strategy for default options
# is to make them all None, to better match the Python style
# for keyword arguments.
# === Property list functional API ============================================
@with_phil
def create(PropClassID cls not None):
"""(PropClassID cls) => PropID
Create a new property list as an instance of a class; classes are:
- FILE_CREATE
- FILE_ACCESS
- DATASET_CREATE
- DATASET_XFER
- DATASET_ACCESS
- LINK_CREATE
- LINK_ACCESS
- GROUP_CREATE
- OBJECT_COPY
- OBJECT_CREATE
"""
cdef hid_t newid
newid = H5Pcreate(cls.id)
return propwrap(newid)
# === Class API ===============================================================
cdef class PropID(ObjectID):
"""
Base class for all property lists and classes
"""
@with_phil
def equal(self, PropID plist not None):
"""(PropID plist) => BOOL
Compare this property list (or class) to another for equality.
"""
return <bint>(H5Pequal(self.id, plist.id))
def __richcmp__(self, object other, int how):
cdef bint truthval = 0
with phil:
if how != 2 and how != 3:
return NotImplemented
if type(self) == type(other):
truthval = self.equal(other)
if how == 2:
return truthval
return not truthval
def __hash__(self):
raise TypeError("Property lists are unhashable")
cdef class PropClassID(PropID):
"""
An HDF5 property list class.
* Hashable: Yes, by identifier
* Equality: Logical H5P comparison
"""
def __richcmp__(self, object other, int how):
return PropID.__richcmp__(self, other, how)
def __hash__(self):
""" Since classes are library-created and immutable, they are uniquely
identified by their HDF5 identifiers.
"""
return hash(self.id)
cdef class PropInstanceID(PropID):
"""
Base class for property list instance objects. Provides methods which
are common across all HDF5 property list classes.
* Hashable: No
* Equality: Logical H5P comparison
"""
@with_phil
def copy(self):
"""() => PropList newid
Create a new copy of an existing property list object.
"""
return type(self)(H5Pcopy(self.id))
def get_class(self):
"""() => PropClassID
Determine the class of a property list object.
"""
return PropClassID(H5Pget_class(self.id))
cdef class PropCreateID(PropInstanceID):
"""
Generic object creation property list.
"""
pass
cdef class PropCopyID(PropInstanceID):
"""
Generic object copy property list
"""
@with_phil
def set_copy_object(self, unsigned int flags):
"""(UINT flags)
Set flags for object copying process. Legal flags are
from the h5o.COPY* family:
h5o.COPY_SHALLOW_HIERARCHY_FLAG
Copy only immediate members of a group.
h5o.COPY_EXPAND_SOFT_LINK_FLAG
Expand soft links into new objects.
h5o.COPY_EXPAND_EXT_LINK_FLAG
Expand external link into new objects.
h5o.COPY_EXPAND_REFERENCE_FLAG
Copy objects that are pointed to by references.
h5o.COPY_WITHOUT_ATTR_FLAG
Copy object without copying attributes.
"""
H5Pset_copy_object(self.id, flags)
@with_phil
def get_copy_object(self):
"""() => UINT flags
Get copy process flags. Legal flags are h5o.COPY*.
"""
cdef unsigned int flags
H5Pget_copy_object(self.id, &flags)
return flags
# === Concrete list implementations ===========================================
# File creation
cdef class PropFCID(PropOCID):
"""
File creation property list.
"""
@with_phil
def get_version(self):
"""() => TUPLE version_info
Determine version information of various file attributes.
Elements are:
0. UINT Super block version number
1. UINT Freelist version number
2. UINT Symbol table version number
3. UINT Shared object header version number
"""
cdef herr_t retval
cdef unsigned int super_
cdef unsigned int freelist
cdef unsigned int stab
cdef unsigned int shhdr
H5Pget_version(self.id, &super_, &freelist, &stab, &shhdr)
return (super_, freelist, stab, shhdr)
@with_phil
def set_userblock(self, hsize_t size):
"""(INT/LONG size)
Set the file user block size, in bytes.
Must be a power of 2, and at least 512.
"""
H5Pset_userblock(self.id, size)
@with_phil
def get_userblock(self):
"""() => LONG size
Determine the user block size, in bytes.
"""
cdef hsize_t size
H5Pget_userblock(self.id, &size)
return size
@with_phil
def set_sizes(self, size_t addr, size_t size):
"""(UINT addr, UINT size)
Set the addressing offsets and lengths for objects
in an HDF5 file, in bytes.
"""
H5Pset_sizes(self.id, addr, size)
@with_phil
def get_sizes(self):
"""() => TUPLE sizes
Determine addressing offsets and lengths for objects in an
HDF5 file, in bytes. Return value is a 2-tuple with values:
0. UINT Address offsets
1. UINT Lengths
"""
cdef size_t addr
cdef size_t size
H5Pget_sizes(self.id, &addr, &size)
return (addr, size)
@with_phil
def set_link_creation_order(self, unsigned int flags):
""" (UINT flags)
Set tracking and indexing of creation order for links added to this group
flags -- h5p.CRT_ORDER_TRACKED, h5p.CRT_ORDER_INDEXED
"""
H5Pset_link_creation_order(self.id, flags)
@with_phil
def get_link_creation_order(self):
""" () -> UINT flags
Get tracking and indexing of creation order for links added to this group
"""
cdef unsigned int flags
H5Pget_link_creation_order(self.id, &flags)
return flags
@with_phil
def set_file_space_strategy(self, unsigned int strategy, bint persist,
unsigned long long threshold):
""" (UINT strategy, BOOL persist, ULONGLONG threshold)
Set the file space handling strategy and persisting free-space values.
"""
H5Pset_file_space_strategy(self.id, <H5F_fspace_strategy_t>strategy,
<hbool_t>persist, <hsize_t>threshold)
@with_phil
def get_file_space_strategy(self):
""" () => TUPLE(UINT strategy, BOOL persist, ULONGLONG threshold)
Retrieve the file space handling strategy, persisting free-space
condition and threshold value for a file creation property list.
"""
cdef H5F_fspace_strategy_t strategy
cdef hbool_t persist
cdef hsize_t threshold
H5Pget_file_space_strategy(self.id, &strategy, &persist, &threshold)
return (strategy, persist, threshold)
@with_phil
def set_file_space_page_size(self, hsize_t fsp_size):
""" (LONG fsp_size)
Set the file space page size used in paged aggregation and paged
buffering. Minimum page size is 512 bytes. A value less than 512 will raise
an error. The size set may not be changed for the life of the file.
"""
H5Pset_file_space_page_size(self.id, <hsize_t>fsp_size)
@with_phil
def get_file_space_page_size(self):
""" () -> LONG fsp_size
Retrieve the file space page size.
"""
cdef hsize_t fsp_size
H5Pget_file_space_page_size(self.id, &fsp_size)
return fsp_size
# Dataset creation
cdef class PropDCID(PropOCID):
"""
Dataset creation property list.
"""
@with_phil
def set_layout(self, int layout_code):
"""(INT layout_code)
Set dataset storage strategy; legal values are:
- h5d.COMPACT
- h5d.CONTIGUOUS
- h5d.CHUNKED
- h5d.VIRTUAL (If using HDF5 library version 1.10 or later)
"""
H5Pset_layout(self.id, <H5D_layout_t>layout_code)
@with_phil
def get_layout(self):
"""() => INT layout_code
Determine the storage strategy of a dataset; legal values are:
- h5d.COMPACT
- h5d.CONTIGUOUS
- h5d.CHUNKED
- h5d.VIRTUAL (If using HDF5 library version 1.10 or later)
"""
return <int>H5Pget_layout(self.id)
@with_phil
def set_chunk(self, object chunksize):
"""(TUPLE chunksize)
Set the dataset chunk size. It's up to you to provide
values which are compatible with your dataset.
"""
cdef int rank
cdef hsize_t* dims
dims = NULL
require_tuple(chunksize, 0, -1, b"chunksize")
rank = len(chunksize)
dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
try:
convert_tuple(chunksize, dims, rank)
H5Pset_chunk(self.id, rank, dims)
finally:
efree(dims)
@with_phil
def get_chunk(self):
"""() => TUPLE chunk_dimensions
Obtain the dataset chunk size, as a tuple.
"""
cdef int rank
cdef hsize_t *dims
rank = H5Pget_chunk(self.id, 0, NULL)
assert rank >= 0
dims = <hsize_t*>emalloc(sizeof(hsize_t)*rank)
try:
H5Pget_chunk(self.id, rank, dims)
tpl = convert_dims(dims, rank)
return tpl
finally:
efree(dims)
@with_phil
def set_fill_value(self, ndarray value not None):
"""(NDARRAY value)
Set the dataset fill value. The object provided should be an
0-dimensional NumPy array; otherwise, the value will be read from
the first element.
"""
from .h5t import check_string_dtype
cdef TypeID tid
cdef char * c_ptr
check_numpy_read(value, -1)
# check for strings
# create correct typeID and pointer to c_str
string_info = check_string_dtype(value.dtype)
if string_info is not None:
# if needed encode fill_value
fill_value = value.item()
if not isinstance(fill_value, bytes):
fill_value = fill_value.encode(string_info.encoding)
c_ptr = fill_value
tid = py_create(value.dtype, logical=1)
H5Pset_fill_value(self.id, tid.id, &c_ptr)
return
tid = py_create(value.dtype)
H5Pset_fill_value(self.id, tid.id, value.data)
@with_phil
def get_fill_value(self, ndarray value not None):
"""(NDARRAY value)
Read the dataset fill value into a NumPy array. It will be
converted to match the array dtype. If the array has nonzero
rank, only the first element will contain the value.
"""
from .h5t import check_string_dtype
cdef TypeID tid
cdef char * c_ptr = NULL
check_numpy_write(value, -1)
# check for vlen strings
# create correct typeID and convert from c_str pointer to string
string_info = check_string_dtype(value.dtype)
if string_info is not None and string_info.length is None:
tid = py_create(value.dtype, logical=1)
ret = H5Pget_fill_value(self.id, tid.id, &c_ptr)
if c_ptr == NULL:
# If the pointer is NULL (either the value did not get changed,
# or maybe the 0 length string, it's unclear currently), if
# PyBytes_FromString is called on the pointer, we get a
# segfault. If we set the value to empty bytes, then we
# shouldn't segfault.
value[0] = b""
return
fill_value = c_ptr
value[0] = fill_value
return
tid = py_create(value.dtype)
H5Pget_fill_value(self.id, tid.id, value.data)
@with_phil
def fill_value_defined(self):
"""() => INT fill_status
Determine the status of the dataset fill value. Return values are:
- h5d.FILL_VALUE_UNDEFINED
- h5d.FILL_VALUE_DEFAULT
- h5d.FILL_VALUE_USER_DEFINED
"""
cdef H5D_fill_value_t val
H5Pfill_value_defined(self.id, &val)
return <int>val
@with_phil
def set_fill_time(self, int fill_time):
"""(INT fill_time)
Define when fill values are written to the dataset. Legal
values (defined in module h5d) are:
- h5d.FILL_TIME_ALLOC
- h5d.FILL_TIME_NEVER
- h5d.FILL_TIME_IFSET
"""
H5Pset_fill_time(self.id, <H5D_fill_time_t>fill_time)
@with_phil
def get_fill_time(self):
""" () => INT
Determine when fill values are written to the dataset. Legal
values (defined in module h5d) are:
- h5d.FILL_TIME_ALLOC
- h5d.FILL_TIME_NEVER
- h5d.FILL_TIME_IFSET
"""
cdef H5D_fill_time_t fill_time
H5Pget_fill_time(self.id, &fill_time)
return <int>fill_time
@with_phil
def set_alloc_time(self, int alloc_time):
"""(INT alloc_time)
Set the storage space allocation time. One of h5d.ALLOC_TIME*.
"""
H5Pset_alloc_time(self.id, <H5D_alloc_time_t>alloc_time)
@with_phil
def get_alloc_time(self):
"""() => INT alloc_time
Get the storage space allocation time. One of h5d.ALLOC_TIME*.
"""
cdef H5D_alloc_time_t alloc_time
H5Pget_alloc_time(self.id, &alloc_time)
return <int>alloc_time
# === Filter functions ====================================================
@with_phil
def set_filter(self, int filter_code, unsigned int flags=0, object values=None):
"""(INT filter_code, UINT flags=0, TUPLE values=None)
Set a filter in the pipeline. Params are:
filter_code
One of the following:
- h5z.FILTER_DEFLATE
- h5z.FILTER_SHUFFLE
- h5z.FILTER_FLETCHER32
- h5z.FILTER_SZIP
flags
Bit flags (h5z.FLAG*) setting filter properties
values
TUPLE of UINTs giving auxiliary data for the filter
"""
cdef size_t nelements
cdef unsigned int *cd_values
cdef int i
cd_values = NULL
require_tuple(values, 1, -1, b"values")
try:
if values is None or len(values) == 0:
nelements = 0
cd_values = NULL
else:
nelements = len(values)
cd_values = <unsigned int*>emalloc(sizeof(unsigned int)*nelements)
for i in range(nelements):
cd_values[i] = int(values[i])
H5Pset_filter(self.id, <H5Z_filter_t>filter_code, flags, nelements, cd_values)
finally:
efree(cd_values)
@with_phil
def all_filters_avail(self):
"""() => BOOL
Determine if all the filters in the pipelist are available to
the library.
"""
return <bint>(H5Pall_filters_avail(self.id))
@with_phil
def get_nfilters(self):
"""() => INT
Determine the number of filters in the pipeline.
"""
return H5Pget_nfilters(self.id)
@with_phil
def get_filter(self, int filter_idx):
"""(UINT filter_idx) => TUPLE filter_info
Get information about a filter, identified by its index. Tuple
elements are:
0. INT filter code (h5z.FILTER*)
1. UINT flags (h5z.FLAG*)
2. TUPLE of UINT values; filter aux data (16 values max)
3. STRING name of filter (256 chars max)
"""
cdef list vlist
cdef int filter_code
cdef unsigned int flags
cdef size_t nelements
cdef unsigned int cd_values[16]
cdef char name[257]
cdef int i
nelements = 16 # HDF5 library actually complains if this is too big.
if filter_idx < 0:
raise ValueError("Filter index must be a non-negative integer")
filter_code = <int>H5Pget_filter(self.id, filter_idx, &flags,
&nelements, cd_values, 256, name, NULL)
name[256] = c'\0' # in case it's > 256 chars
vlist = []
for i in range(nelements):
vlist.append(cd_values[i])
return (filter_code, flags, tuple(vlist), name)
@with_phil
def _has_filter(self, int filter_code):
"""(INT filter_code)
Slow & stupid method to determine if a filter is used in this
property list. Used because the HDF5 function H5Pget_filter_by_id
is broken.
"""
cdef int i, nfilters
nfilters = self.get_nfilters()
for i in range(nfilters):
if self.get_filter(i)[0] == filter_code:
return True
return False
@with_phil
def get_filter_by_id(self, int filter_code):
"""(INT filter_code) => TUPLE filter_info or None
Get information about a filter, identified by its code (one
of h5z.FILTER*). If the filter doesn't exist, returns None.
Tuple elements are:
0. UINT flags (h5z.FLAG*)
1. TUPLE of UINT values; filter aux data (16 values max)
2. STRING name of filter (256 chars max)
"""
cdef list vlist
cdef unsigned int flags
cdef size_t nelements
cdef unsigned int cd_values[16]
cdef char name[257]
cdef herr_t retval
cdef int i
nelements = 16 # HDF5 library actually complains if this is too big.
if not self._has_filter(filter_code):
# Avoid library segfault
return None
retval = H5Pget_filter_by_id(self.id, <H5Z_filter_t>filter_code,
&flags, &nelements, cd_values, 256, name, NULL)
assert nelements <= 16
name[256] = c'\0' # In case HDF5 doesn't terminate it properly
vlist = []
for i in range(nelements):
vlist.append(cd_values[i])
return (flags, tuple(vlist), name)
@with_phil
def remove_filter(self, int filter_class):
"""(INT filter_class)
Remove a filter from the pipeline. The class code is one of
h5z.FILTER*.
"""
H5Premove_filter(self.id, <H5Z_filter_t>filter_class)
@with_phil
def set_deflate(self, unsigned int level=5):
"""(UINT level=5)
Enable deflate (gzip) compression, at the given level.
Valid levels are 0-9, default is 5.
"""
H5Pset_deflate(self.id, level)
@with_phil
def set_fletcher32(self):
"""()
Enable Fletcher32 error correction on this list.
"""
H5Pset_fletcher32(self.id)
@with_phil
def set_shuffle(self):
"""()
Enable to use of the shuffle filter. Use this immediately before
the deflate filter to increase the compression ratio.
"""
H5Pset_shuffle(self.id)
@with_phil
def set_szip(self, unsigned int options, unsigned int pixels_per_block):
"""(UINT options, UINT pixels_per_block)
Enable SZIP compression. See the HDF5 docs for argument meanings,
and general restrictions on use of the SZIP format.
"""
H5Pset_szip(self.id, options, pixels_per_block)
@with_phil
def set_scaleoffset(self, H5Z_SO_scale_type_t scale_type, int scale_factor):
'''(H5Z_SO_scale_type_t scale_type, INT scale_factor)
Enable scale/offset (usually lossy) compression; lossless (e.g. gzip)
compression and other filters may be applied on top of this.
Note that error detection (i.e. fletcher32) cannot precede this in
the filter chain, or else all reads on lossily-compressed data will
fail.'''
H5Pset_scaleoffset(self.id, scale_type, scale_factor)
# === External dataset functions ===========================================
@with_phil
def set_external(self, name, offset, size):
'''(STR name, UINT offset, UINT size)
Adds an external file to the list of external files for the dataset.
The first call sets the external storage property in the property list,
thus designating that the dataset will be stored in one or more non-HDF5
file(s) external to the HDF5 file.'''
H5Pset_external(self.id, name, offset, size)
@with_phil
def get_external_count(self):
"""() => INT
Returns the number of external files for the dataset.
"""
return <int>(H5Pget_external_count(self.id))
@with_phil
def get_external(self, idx=0):
"""(UINT idx=0) => TUPLE external_file_info
Returns information about the indexed external file.
Tuple elements are:
0. STRING name of file (256 chars max)
1. UINT offset
2. UINT size
"""
cdef char name[257]
cdef off_t offset
cdef hsize_t size
cdef herr_t retval
retval = H5Pget_external(self.id, idx, 256, name, &offset, &size)
name[256] = c'\0' # In case HDF5 doesn't terminate name properly
result = None
if retval==0:
result = (name, offset, size)
return result
# === Virtual dataset functions ===========================================
@with_phil
def set_virtual(self, SpaceID vspace not None, char* src_file_name,
char* src_dset_name, SpaceID src_space not None):
"""(SpaceID vspace, STR src_file_name, STR src_dset_name, SpaceID src_space)
Set the mapping between virtual and source datasets.
The virtual dataset is described by its virtual dataspace (vspace)
to the elements. The source dataset is described by the name of the
file where it is located (src_file_name), the name of the dataset
(src_dset_name) and its dataspace (src_space).
"""
H5Pset_virtual(self.id, vspace.id, src_file_name, src_dset_name, src_space.id)
@with_phil
def get_virtual_count(self):
"""() => UINT
Get the number of mappings for the virtual dataset.
"""
cdef size_t count
H5Pget_virtual_count(self.id, &count)
return count
@with_phil
def get_virtual_dsetname(self, size_t index=0):
"""(UINT index=0) => STR
Get the name of a source dataset used in the mapping of the virtual
dataset at the position index.
"""
cdef char* name = NULL
cdef ssize_t size
size = H5Pget_virtual_dsetname(self.id, index, NULL, 0)
name = <char*>emalloc(size+1)
try:
# TODO check return size
H5Pget_virtual_dsetname(self.id, index, name, <size_t>size+1)
src_dset_name = bytes(name).decode('utf-8')
finally:
efree(name)
return src_dset_name
@with_phil
def get_virtual_filename(self, size_t index=0):
"""(UINT index=0) => STR
Get the file name of a source dataset used in the mapping of the
virtual dataset at the position index.
"""
cdef char* name = NULL
cdef ssize_t size
size = H5Pget_virtual_filename(self.id, index, NULL, 0)
name = <char*>emalloc(size+1)
try:
# TODO check return size
H5Pget_virtual_filename(self.id, index, name, <size_t>size+1)
src_fname = bytes(name).decode('utf-8')
finally:
efree(name)
return src_fname
@with_phil
def get_virtual_vspace(self, size_t index=0):
"""(UINT index=0) => SpaceID
Get a dataspace for the selection within the virtual dataset used
in the mapping.
"""
return SpaceID(H5Pget_virtual_vspace(self.id, index))
@with_phil
def get_virtual_srcspace(self, size_t index=0):
"""(UINT index=0) => SpaceID
Get a dataspace for the selection within the source dataset used
in the mapping.
"""
return SpaceID(H5Pget_virtual_srcspace(self.id, index))
# File access
cdef class PropFAID(PropInstanceID):
"""
File access property list
"""
@with_phil
def set_fclose_degree(self, int close_degree):
"""(INT close_degree)
Set the file-close degree, which determines library behavior when
a file is closed when objects are still open. Legal values:
* h5f.CLOSE_WEAK
* h5f.CLOSE_SEMI
* h5f.CLOSE_STRONG
* h5f.CLOSE_DEFAULT
"""
H5Pset_fclose_degree(self.id, <H5F_close_degree_t>close_degree)
@with_phil
def get_fclose_degree(self):
"""() => INT close_degree
- h5fd.