bloscpack 0.16.0

基础

基本压缩

$ blpk compress data.dat

或者

$ blpk c data.dat

…会将文件data.dat压缩到data.dat.blp

基本解压

$ blpk decompress data.dat.blp data.dcmp

或者

$ blpk d data.dat.blp data.dcmp

…会将文件data.dat.blp解压到文件data.dcmp。如果您省略了[<out_file>]参数，Bloscpack会抱怨说文件data.dat已经存在，并拒绝覆盖它

$ blpk decompress data.dat.blp
blpk: error: output file 'data.dat' exists!

如果您知道自己在做什么，可以使用全局选项[-f | --force]来覆盖覆盖检查

$ blpk --force decompress data.dat.blp

顺便说一下，这也适用于压缩

$ blpk compress data.dat
blpk: error: output file 'data.dat.blp' exists!
$ blpk --force compress data.dat

最后，如果您想使用不同的文件名

$ blpk compress data.dat custom.filename.blp

…会将文件data.dat压缩到custom.filename.blp

设置

默认情况下，Blosc 在压缩和解压缩过程中使用的线程数由系统检测到的核心数决定。您可以使用 [-n | --nthreads] 选项来更改此设置

$ blpk --nthreads 1 compress data.dat

Blosc 的压缩可以通过以下选项控制

• [-t | --typesize] Blosc 使用的 Typesize（默认：8）：$ blpk compress --typesize 8 data.dat

• [-l | --level] 压缩级别（默认：7）：$ blpk compress --level 3 data.dat

• [-s | --no-shuffle] 禁用洗牌：$ blpk compress --no-shuffle data.dat

• [-c | --codec] 使用替代编解码器：$ blpk compress --codec lz4 data.dat

此外，还有一些选项可以控制 Bloscpack 文件

• [-z | --chunk-size] 块的期望近似大小，您可以使用可读字符串，如 8M 或 128K 或 max 来使用最大块大小（约 2GB）（默认：1MB）：$ blpk compress --chunk-size 128K data.dat 或 $ blpk c -z max data.dat

• [-k | --checksum <checksum>] 选择要使用的校验和。以下值是允许的：None、adler32、crc32、md5、sha1、sha224、sha256、sha384、sha512（默认：adler32）。正如标题格式所述，每个压缩块都可以存储校验和，这有助于在解压缩时检测损坏：$ blpk compress --checksum crc32 data.dat

• [-o | --no-offsets] 默认情况下，存储各个块的偏移量。这些偏移量包含在内，以便将来允许部分解压缩。此选项禁用了该功能。此外，预留了一定数量的偏移量（默认：10 * ‘nchunks’），以便将数据附加到文件中：$ blpk compress --no-offsets data.dat

信息子命令

如果您只需要有关文件如何压缩的一些信息 [i | info]

$ blpk info data.dat.blp
blpk: BloscpackHeader:
blpk:     format_version: 3
blpk:     offsets: True
blpk:     metadata: False
blpk:     checksum: 'adler32'
blpk:     typesize: 8
blpk:     chunk_size: 1.0M (1048576B)
blpk:     last_chunk: 900.0K (921600B)
blpk:     nchunks: 1526
blpk:     max_app_chunks: 15260
blpk: 'offsets':
blpk: [134320,459218,735869,986505,1237646,...]
blpk: First chunk blosc header:
blpk: OrderedDict([('version', 2), ('versionlz', 1), ('flags', 1), ('typesize', 8), ('nbytes', 1048576), ('blocksize', 131072), ('ctbytes', 324894)])
blpk: First chunk blosc flags:
blpk: OrderedDict([('byte_shuffle', True), ('pure_memcpy', False), ('bit_shuffle', False), ('split_blocks', False), ('codec', 'blosclz')])

重要的是，标题和标志信息仅适用于第一个块。通常这不会成问题，因为 bloscpack 压缩文件往往具有类似的设置，如使用的编解码器、typesize 等。然而，没有任何东西可以阻止您使用不同的设置将数据追加到现有的 bloscpack 文件中。例如，文件的一半可能使用‘blosclz’压缩，而文件的另一半可能使用‘lz4’压缩。在任何情况下，请注意，输出应被视为对所有块可能正确的指示，但不一定是必然的。

添加元数据

使用 [-m | --metadata] 选项，您可以将文件中的 JSON 包括在内

$ cat meta.json
{"dtype": "float64", "shape": [200000000], "container": "numpy"}
$ blpk compress --chunk-size=512M --metadata meta.json data.dat
$ blpk info data.dat.blp
blpk: BloscpackHeader:
blpk:     format_version: 3
blpk:     offsets: True
blpk:     metadata: True
blpk:     checksum: 'adler32'
blpk:     typesize: 8
blpk:     chunk_size: 512.0M (536870912B)
blpk:     last_chunk: 501.88M (526258176B)
blpk:     nchunks: 3
blpk:     max_app_chunks: 30
blpk: 'offsets':
blpk: [922,78074943,140783242,...]
blpk: 'metadata':
blpk: {   u'container': u'numpy', u'dtype': u'float64', u'shape': [200000000]}
blpk: MetadataHeader:
blpk:     magic_format: 'JSON'
blpk:     meta_options: '00000000'
blpk:     meta_checksum: 'adler32'
blpk:     meta_codec: 'zlib'
blpk:     meta_level: 6
blpk:     meta_size: 59.0B (59B)
blpk:     max_meta_size: 590.0B (590B)
blpk:     meta_comp_size: 58.0B (58B)
blpk:     user_codec: ''

在解压缩时会打印出来

$ blpk decompress data.dat.blp
blpk: Metadata is:
blpk: '{u'dtype': u'float64', u'shape': [200000000], u'container': u'numpy'}'

追加

您还可以将数据追加到现有的 bloscpack 压缩文件中

$ blpk append data.dat.blp data.dat

然而，在追加数据量方面存在一些限制。例如，如果存在偏移量部分，必须有足够的空间来存储追加块偏移量。如果没有偏移量，则可以在由最大块数和块大小限制的情况下尽可能追加更多数据。此外，对压缩选项也有限制。例如，无法更改所使用的校验和。但是，可以更改追加块的压缩级别、类型大小和洗牌选项。

请注意，截至 v0.5.0，追加仍然被视为实验性的。

详细和调试模式

最后，有两个互斥的选项用于控制输出量。

第一个会打印基本信息，[-v | --verbose]

$ blpk --verbose compress --chunk-size 0.5G data.dat
blpk: using 4 threads
blpk: getting ready for compression
blpk: input file is: 'data.dat'
blpk: output file is: 'data.dat.blp'
blpk: input file size: 1.49G (1600000000B)
blpk: nchunks: 3
blpk: chunk_size: 512.0M (536870912B)
blpk: last_chunk_size: 501.88M (526258176B)
blpk: output file size: 198.39M (208028617B)
blpk: compression ratio: 7.691250
blpk: done

… 而 [-d | --debug] 会打印详细的运行情况

$ blpk --debug compress --chunk-size 0.5G data.dat
blpk: command line argument parsing complete
blpk: command line arguments are:
blpk:     force: False
blpk:     verbose: False
blpk:     offsets: True
blpk:     checksum: adler32
blpk:     subcommand: compress
blpk:     out_file: None
blpk:     metadata: None
blpk:     cname: blosclz
blpk:     in_file: data.dat
blpk:     chunk_size: 536870912
blpk:     debug: True
blpk:     shuffle: True
blpk:     typesize: 8
blpk:     clevel: 7
blpk:     nthreads: 4
blpk: using 4 threads
blpk: getting ready for compression
blpk: input file is: 'data.dat'
blpk: output file is: 'data.dat.blp'
blpk: input file size: 1.49G (1600000000B)
blpk: nchunks: 3
blpk: chunk_size: 512.0M (536870912B)
blpk: last_chunk_size: 501.88M (526258176B)
blpk: BloscArgs:
blpk:     typesize: 8
blpk:     clevel: 7
blpk:     shuffle: True
blpk:     cname: 'blosclz'
blpk: BloscpackArgs:
blpk:     offsets: True
blpk:     checksum: 'adler32'
blpk:     max_app_chunks: <function <lambda> at 0x1182de8>
blpk: metadata_args will be silently ignored
blpk: max_app_chunks is a callable
blpk: max_app_chunks was set to: 30
blpk: BloscpackHeader:
blpk:     format_version: 3
blpk:     offsets: True
blpk:     metadata: False
blpk:     checksum: 'adler32'
blpk:     typesize: 8
blpk:     chunk_size: 512.0M (536870912B)
blpk:     last_chunk: 501.88M (526258176B)
blpk:     nchunks: 3
blpk:     max_app_chunks: 30
blpk: raw_bloscpack_header: 'blpk\x03\x01\x01\x08\x00\x00\x00 \x00\x10^\x1f\x03\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00'
blpk: Handle chunk '0'
blpk: checksum (adler32): '\x1f\xed\x1e\xf4'
blpk: chunk handled, in: 512.0M (536870912B) out: 74.46M (78074017B)
blpk: Handle chunk '1'
blpk: checksum (adler32): ')\x1e\x08\x88'
blpk: chunk handled, in: 512.0M (536870912B) out: 59.8M (62708295B)
blpk: Handle chunk '2' (last)
blpk: checksum (adler32): '\xe8\x18\xa4\xac'
blpk: chunk handled, in: 501.88M (526258176B) out: 64.13M (67245997B)
blpk: Writing '3' offsets: '[296, 78074317, 140782616]'
blpk: Raw offsets: '(\x01\x00\x00\x00\x00\x00\x00\xcdQ\xa7\x04\x00\x00\x00\x00\x18,d\x08\x00\x00\x00\x00'
blpk: output file size: 198.39M (208028617B)
blpk: compression ratio: 7.691250
blpk: done

参数

三种参数类型是

• BloscArgs

• BloscpackArgs

• MetadataArgs

如 bloscpack/args.py 中定义。实例化任何一个都会创建一个带有默认设置的对象。默认值在 bloscpack/defaults.py 中定义。您可以在以下列出的高级函数中使用这些参数。

您可以通过传递相应的关键字参数来覆盖任何或所有默认值，例如

>>> b = BloscArgs()               # will create a default args object
>>> b = BloscArgs(clevel=4)       # change compression level to 4
>>> b = BloscArgs(typesize=4,     # change the typesize to 4
>>> ...           clevel=9,       # change the compression level to 9
>>> ...           shuffle=False,  # deactivate the shuffle filter
>>> ...           cname='lz4')    # let lz4 be the internal codec

class BloscArgs(MutableMappingObject):
    """ Object to hold Blosc arguments.

    Parameters
    ----------
    typesize : int
        The typesize used
    clevel : int
        Compression level
    shuffle : boolean
        Whether or not to activate the shuffle filter
    cname: str
        Name of the internal code to use

    """

class BloscpackArgs(MutableMappingObject):
    """ Object to hold BloscPack arguments.

    Parameters
    ----------
    offsets : boolean
        Whether to include space for offsets
    checksum : str
        Name of the checksum to use or None/'None'
    max_app_chunks : int or callable on number of chunks
        How much space to reserve in the offsets for chunks to be appended.

    """

class MetadataArgs(MutableMappingObject):
    """ Object to hold the metadata arguments.

    Parameters
    ----------
    magic_format : 8 bytes
        Format identifier for the metadata
    meta_checksum : str
        Checksum to be used for the metadata
    meta_codec : str
        Codec to be used to compress the metadata
    meta_level : int
        Compression level for metadata
    max_meta_size : int or callable on metadata size
        How much space to reserve for additional metadata

    """

文件 / 字节

以下高级函数可用于将数据和字节对象压缩和解压缩到文件和字节对象中

• pack_file_to_file

• unpack_file_from_file

• pack_bytes_to_file

• unpack_bytes_from_file

• pack_bytes_to_bytes

• unpack_bytes_from_bytes

除了目标参数（如文件和字节）之外，每个 pack_* 函数还接受以下参数

chunk_size : int
    the desired chunk size in bytes
metadata : dict
    the metadata dict
blosc_args : BloscArgs
    blosc args
bloscpack_args : BloscpackArgs
    bloscpack args
metadata_args : MetadataArgs
    metadata args

以下是它们的签名

def pack_file_to_file(in_file, out_file,
                      chunk_size=DEFAULT_CHUNK_SIZE,
                      metadata=None,
                      blosc_args=None,
                      bloscpack_args=None,
                      metadata_args=None):

def unpack_file_from_file(in_file, out_file):


def pack_bytes_to_file(bytes_, out_file,
                       chunk_size=DEFAULT_CHUNK_SIZE,
                       metadata=None,
                       blosc_args=None,
                       bloscpack_args=None,
                       metadata_args=None):

def unpack_bytes_from_file(compressed_file):

def pack_bytes_to_bytes(bytes_,
                        chunk_size=DEFAULT_CHUNK_SIZE,
                        metadata=None,
                        blosc_args=None,
                        bloscpack_args=None,
                        metadata_args=None,
                        ):


def unpack_bytes_from_bytes(bytes_):

Numpy

Numpy 数组可以作为 Bloscpack 文件进行序列化，以下是一个非常简短的示例

>>> a = np.linspace(0, 1, 3e8)
>>> print a.size, a.dtype
300000000 float64
>>> bp.pack_ndarray_to_file(a, 'a.blp')
>>> b = bp.unpack_ndarray_from_file('a.blp')
>>> (a == b).all()
True

查看生成的文件，我们可以看到保存的 Numpy 元数据

$ lh a.blp
-rw------- 1 esc esc 266M Aug 13 23:21 a.blp

$ blpk info a.blp
blpk: BloscpackHeader:
blpk:     format_version: 3
blpk:     offsets: True
blpk:     metadata: True
blpk:     checksum: 'adler32'
blpk:     typesize: 8
blpk:     chunk_size: 1.0M (1048576B)
blpk:     last_chunk: 838.0K (858112B)
blpk:     nchunks: 2289
blpk:     max_app_chunks: 22890
blpk: 'offsets':
blpk: [202170,408064,554912,690452,819679,...]
blpk: 'metadata':
blpk: {   u'container': u'numpy',
blpk:     u'dtype': u'<f8',
blpk:     u'order': u'C',
blpk:     u'shape': [300000000]}
blpk: MetadataHeader:
blpk:     magic_format: 'JSON'
blpk:     meta_options: '00000000'
blpk:     meta_checksum: 'adler32'
blpk:     meta_codec: 'zlib'
blpk:     meta_level: 6
blpk:     meta_size: 67.0B (67B)
blpk:     max_meta_size: 670.0B (670B)
blpk:     meta_comp_size: 62.0B (62B)
blpk:     user_codec: ''

或者，我们也可以使用字符串作为存储

>>> a = np.linspace(0, 1, 3e8)
>>> c = pack_ndarray_to_bytes(a)
>>> b = unpack_ndarray_from_bytes(c)
>>> (a == b).all()
True

或者使用其他压缩器

>>> a = np.linspace(0, 1, 3e8)
>>> c = pack_ndarray_to_bytes(a, blosc_args=BloscArgs(cname='lz4'))
>>> b = unpack_ndarray_from_bytes(c)
>>> (a == b).all()
True

def pack_ndarray_to_file(ndarray, filename,
                         chunk_size=DEFAULT_CHUNK_SIZE,
                         blosc_args=None,
                         bloscpack_args=None,
                         metadata_args=None):

def pack_ndarray_to_bytes(ndarray,
                          chunk_size=DEFAULT_CHUNK_SIZE,
                          blosc_args=None,
                          bloscpack_args=None,
                          metadata_args=None):

def unpack_ndarray_from_file(filename):

def unpack_ndarray_from_bytes(str_):

如果您对 Bloscpack 与其他 Numpy 数组序列化格式的性能感兴趣，请参阅 EuroScipy 2013 会议论文集中 Bloscpack 论文中提供的基准测试。

安装依赖项

测试需要一些额外的库，您可以使用以下命令从 PyPi 安装

$ pip install -r test_requirements.txt
[...]

基本测试

基本测试，运行快速

$ nosetests
[...]

更重的测试

使用较大文件进行的扩展测试，可能需要一些时间，但会对内存很有帮助

$ nosetests test/test_file_io.py:pack_unpack_hard
[...]

使用巨大文件进行的扩展测试。这个测试要花很长时间，需要大量的内存（5G-6G）和大量的磁盘空间（10G）。使用 -s 打印进度

$ nosetests -s test/test_file_io.py:pack_unpack_extreme
[...]

请注意，某些压缩/解压缩测试会创建临时文件（在 UNIXoid 系统上位于 /tmp/blpk* 下），这些文件在相应测试完成（无论成功与否）或测试被终止（例如，使用 ctrl-c）时删除。

在罕见情况下，例如在触发删除操作时中断删除，您可能会留下污染临时空间的大型文件。根据您的分区方案等，重复这样做可能会导致您在文件系统上耗尽空间。

命令行界面测试

命令行界面使用cram进行测试

$ cram --verbose test_cmdline/*.cram
[...]

覆盖率

要确定覆盖率，可以将cram测试和单元测试的覆盖率合并在一起

$ COVERAGE=1 cram --verbose test_cmdline/*.cram
[...]
$nosetests --with-coverage --cover-package=bloscpack
[...]

测试运行器

要运行命令行界面测试、单元测试和分析覆盖率，请使用便捷的test.sh运行器

$ ./test.sh
[...]

头描述

以下32位头自版本0.3.0以来用于Bloscpack。头格式的设计目标是包含尽可能多的信息，以便在未来实现有趣的事情，并尽可能通用，以便Blaze/BLZ的持久层可以在不修改头格式的情况下实现。

以下ASCII表示显示了头的布局

|-0-|-1-|-2-|-3-|-4-|-5-|-6-|-7-|-8-|-9-|-A-|-B-|-C-|-D-|-E-|-F-|
| b   l   p   k | ^ | ^ | ^ | ^ |   chunk-size  |  last-chunk   |
                  |   |   |   |
      version ----+   |   |   |
      options --------+   |   |
     checksum ------------+   |
     typesize ----------------+

|-0-|-1-|-2-|-3-|-4-|-5-|-6-|-7-|-8-|-9-|-A-|-B-|-C-|-D-|-E-|-F-|
|            nchunks            |        max-app-chunks         |

前4个字节是魔数字符串 blpk。接着是4个字节，用于存储文件中激活的特性信息。然后是4个字节表示 chunk-size，再接着是4个字节表示 last-chunk-size，8个字节表示数据块的数量，即 nchunks，最后是8个字节表示可以附加到该文件中的最大数据块数量，即 max-app-chunks。

实际上，将数据块数量存储为有符号8字节整数，将数据块数量限制为 2**63-1 = 9223372036854775807，但在实际应用中，这不应该有任何影响，因为，即使在 chunk-size 的默认值 1MB 适中时，我们仍然可以存储高达 8ZB (！）的文件。考虑到到2012年，Zettabye文件系统（zfs）中单个文件的最大大小为 16EB，Bloscpack 应该在未来几年内都是安全的。

头部条目的描述

所有条目都是小端。

版本：

(uint8) Bloscpack头部的格式版本，以确保在向前不兼容的情况下引发异常。

选项：

(bitfield) 一个位字段，允许设置该文件中的某些选项。

位0 (0x01):

如果该文件中有数据块偏移量。

位1 (0x02):

如果该文件中有元数据。

checksum：

(uint8) 所使用的校验和。以下在python标准库中可用的校验和应该得到支持。校验和始终在压缩数据上计算，并放置在数据块之后。

0:

无校验和

1:

zlib.adler32

2:

zlib.crc32

3:

hashlib.md5

4:

hashlib.sha1

5:

hashlib.sha224

6:

hashlib.sha256

7:

hashlib.sha384

8:

hashlib.sha512

typesize：

(uint8) 数据块中数据的类型大小。目前，假设类型大小是统一的。分配的空间与Blosc头部相同。

chunk-size：

(int32) 表示chunk-size。由于Blosc的最大缓冲区大小为2GB，所以有符号32位整数就足够了（2GB = 2**31 bytes）。特殊值 -1 表示chunk-size未知或可能是不均匀的。

last-chunk：

(int32) 表示最后一个数据块的大小。与chunk-size一样，int32足够了。同样，-1 表示该值未知。

nchunks：

(int64) 文件中使用的总数据块数量。给定一个字节大小的chunk-size，总数据块数量为 2**63。这相当于最大文件大小为8EB（8EB = 2*63 bytes），应该足够未来几年使用。同样，-1 表示该数量未知。

max-app-chunks：

(int64) 可以附加到该文件上的最大块数（不包括 nchunks）。只有在存在偏移量部分并且 nchunks 已知（不是 -1）的情况下才有效，如果这两个条件中任何一个不适用，则应设置为 0。

整体文件大小可以通过以下公式计算：chunk-size * (nchunks - 1) + last-chunk-size。在流式场景中，可以使用 -1 作为占位符。例如，如果在创建头部时不知道总块数或最后一个块的大小。

头部条目存在以下约束

• last-chunk 必须小于或等于 chunk-size。

• nchunks + max_app_chunks 必须小于或等于 int64 的最大值。

元数据部分的描述

本部分位于头部之后。它由元数据部分头部、序列化并可能压缩的数据部分以及可能随后的预留空间来调整数据部分大小，可能还跟随校验和。

因此，该部分的布局是

|-metadata-header-|-data-|-prealloc-|-checksum-|

头部具有以下布局

|-0-|-1-|-2-|-3-|-4-|-5-|-6-|-7-|-8-|-9-|-A-|-B-|-C-|-D-|-E-|-F-|
|         magic-format          | ^ | ^ | ^ | ^ |   meta-size   |
                                  |   |   |   |
              meta-options -------+   |   |   |
              meta-checksum ----------+   |   |
              meta-codec -----------------+   |
              meta-level ---------------------+

|-0-|-1-|-2-|-3-|-4-|-5-|-6-|-7-|-8-|-9-|-A-|-B-|-C-|-D-|-E-|-F-|
| max-meta-size |meta-comp-size |            user-codec         |

magic-format:

(8 字节 ASCII 字符串) 数据通常是某种二进制序列化字符串数据，例如 JSON、BSON、YAML 或 Protocol-Buffers。格式标识符应放置在此字段中。

meta-options:

(位域) 一个位域，允许在此元数据部分中设置某些选项。目前未使用。

meta-checksum:

用于元数据的校验和。与数据相同的校验和都可用。

meta-codec:

(unit8) 用于压缩元数据的编解码器。截至 Bloscpack 版本 0.3.0，支持以下编解码器。

0:

无编解码器

1:

zlib (DEFLATE)

meta-level:

(unit8) 编解码器使用的压缩级别。如果 codec 是 0，即元数据未压缩，则此值也必须是 0。

meta-size:

(uint32) 未压缩元数据的大小。

max-meta-size:

(uint32) 为数据部分分配的总空间。

meta-comp-size:

(uint32) 如果元数据已压缩，则此值表示元数据占用的总空间。如果数据未压缩，则此值与 meta-size 相同。从某种意义上说，这是元数据部分中实际使用的空间量。

user-codec:

预留空间以供使用额外的编解码器。例如，编解码器标识的 4 字节魔法字符串和编解码器参数的编码 4 字节。

预留用于扩大元数据部分的总空间是：max-meta-size - meta-comp-size。

序列化元数据的 JSON 示例

'{"dtype": "float64", "shape": [1024], "others": []}'

如果请求压缩，但压缩后的大小大于未压缩的大小，则不会自动激活元数据的压缩。

截至Bloscpack版本 0.3.0，仅支持并使用JSON序列化器，并以四个空格字节作为标识符的字符串 JSON 进行标识。由于JSON和其他建议的序列化器都有局限性，因此只能存储Python结构的一小部分，因此在序列化某些类型的元数据之前，可能必须进行一些额外的对象处理。

偏移量条目的描述

在元数据部分之后，是可变长度的块偏移量部分。用于加速定位的块偏移量应指向文件中的块。偏移量（如果启用）位于头部之后。每个偏移量是一个64位有符号小端整数（int64）。值为 -1 表示未知偏移量。最初，所有偏移量都应初始化为 -1 并在写入所有块后填充。因此，如果文件压缩提前失败或被中止，所有偏移量都应具有值 -1。此外，为允许文件增长而预留的任何未使用的偏移量条目也应设置为 -1。每个偏移量表示块在文件中的确切位置，这样定位到偏移量，文件指针将定位到下一个16个字节给出Blosc头部，该头部位于所需块的开头。

块格式的描述

如前所述，每个块只是一个包括头部的Blosc压缩字符串。Blosc头部（截至 v1.0.0）是16字节，如下所示

|-0-|-1-|-2-|-3-|-4-|-5-|-6-|-7-|-8-|-9-|-A-|-B-|-C-|-D-|-E-|-F-|
  ^   ^   ^   ^ |     nbytes    |   blocksize   |    ctbytes    |
  |   |   |   |
  |   |   |   +--typesize
  |   |   +------flags
  |   +----------versionlz
  +--------------version

前四个是简单的字节，最后三个是每个4字节的未签名整数（uint32）。头部始终是小端。 ctbytes 是包括头部在内的缓冲区长度，nbytes 是未压缩时的数据长度。有关Blosc头部的更详细描述，请参阅Blosc存储库的README_HEADER.rst

开销

根据使用的文件配置，可能会添加恒定或线性开销。Bloscpack头部在任何情况下都添加32字节。如果数据不可压缩，Blosc将为每个块添加16字节的头部。元数据部分显然会增加恒定开销，如果使用，校验和和偏移量都会为文件添加开销。偏移量每个块增加8字节，校验和增加一个固定常数值，该值取决于每个块的校验和。例如，对于 adler32 校验和，为32字节。

文档

• 将单一代读文件重构为 Sphinx 并发布

• 清理并双重检查公共 API 类的文档字符串

命令行

• 静默输出级别

• 允许从命令行设置 ‘max_app_chunks’

• 允许在解压缩期间将元数据保存到文件

• 子命令 e 或 estimate 用于估计未压缩数据的大小。

• 子命令 v 或 verify 用于验证数据完整性

• 添加 –raw-input 和 –raw-output 开关以允许类似以下操作：cat file | blpk –raw-input –raw-output compress > file.blp

• 建立并记录正确的退出代码

• 记录在 Numpy 序列化期间保存的元数据

性能分析和优化

• 使用结构体中只有一个字符串时的更快版本

• 内存分析器，可能可以通过在压缩和解压缩期间重用缓冲区来减少内存使用

• 基准测试不同的编解码器

• 使用行分析器检查代码

• 为 Numpy 数组选择不同的默认值，没有偏移？没有预分配？

库功能

• 可能提供类似于 GzipFile 的 BloscPackFile 抽象

• 允许不预分配元数据的额外空间

• 将操作数据的某些函数集合重构为对象

  • 偏移量（可能）

• 部分解压缩？

• 由于我们现在可能有小块数据，进度条再次变得相关

• 配置文件以在给定机器上存储常用选项

• 打印压缩时间，无论是详细还是调试

• 研究是否可以使用在读取时返回内存视图的 StringIO 对象。

• 实现一个内存视图 Compressed/PlainSource

• 使用 bytearray 从文件中读取块。然后在每次读取时重用该 bytearray 以避免在整个过程中分配和释放字符串。

• 许多函数的关键字参数是全球字典，这是一个坏主意，使用 forzendict 使其不可变。

• 检查是否真的对所有 PlainSinks 进行了校验和检查

• 一系列 NetworkSource/Sinks

• HTTPSource/Sink

杂项

• 在 scipy/numpy 列表、comp.compression、freshmeat、ohloh 上宣布

打包和基础设施

• Debian 软件包（用于 python-blosc 和 bloscpack）

• Conda 食谱（用于 python-blosc 和 bloscpack）

• 使用 tox 测试多个 Python 版本

• 在 travis 和 drone.io 上使用预编译构建