`deflate` — deflate tömörítés és kicsomagolás¶

Ez a modul lehetővé teszi a bináris adatok tömörítését és kicsomagolását a DEFLATE algoritmussal (amelyet gyakran használ a zlib könyvtár és a gzip archiváló). A MicroPython v1.21-ben került hozzáadásra.

Elérhetőség az OpenMV által támogatott lapokon:

Lap	Kicsomagolás	Tömörítés
OpenMV Cam N6	Igen	Nem
OpenMV AE3	Igen	Igen
OpenMV Cam RT1062	Igen	Igen
OpenMV Cam Pure Thermal	Igen	Nem
OpenMV Cam M4	Igen	Nem
OpenMV Cam M7	Igen	Nem
OpenMV Cam H7	Igen	Nem
OpenMV Cam H7 Plus	Igen	Nem
Arduino Giga	Igen	Nem
Arduino Portenta H7	Igen	Nem
Arduino Nicla Vision	Igen	Nem
Arduino Nano 33 BLE Sense	Igen	Nem
Arduino Nano RP2040 Connect	Igen	Nem

Osztályok¶

class deflate.DeflateIO(stream: Any, format: int = AUTO, wbits: int = 0, close: bool = False, /)¶

Ez az osztály egy stream becsomagolására használható, amely bármilyen stream-szerű objektum lehet, például fájl, socket vagy stream (beleértve az io.BytesIO objektumot). Maga is egy stream, és megvalósítja a szabványos read/readinto/write/close metódusokat.

A stream-nek blokkoló streamnek kell lennie. A nem blokkoló streamek jelenleg nem támogatottak.

A format az alább definiált konstansok bármelyikére beállítható, és alapértelmezetten AUTO, amely kicsomagoláskor automatikusan felismeri a gzip vagy zlib streameket, tömörítéskor pedig nyers streamet generál.

A wbits paraméter a DEFLATE szótár ablakméretének 2-es alapú logaritmusát állítja be. Például a wbits 10-re állítása az ablakméretet 1024 bájtra állítja. Az érvényes értékek 5-től 15-ig terjednek (a 32 és 32k bájt közötti ablakméreteknek megfelelően).

Ha a wbits 0-ra van állítva (ez az alapértelmezés), akkor tömörítéshez 256 bájtos ablakméretet használ (mintha a wbits 8-ra lenne állítva). Kicsomagoláshoz a formátumtól függ:

A RAW 256 bájtot fog használni (a wbits 8-ra állításának megfelelően).
A ZLIB (vagy AUTO zlib felismerése esetén) a zlib fejlécben szereplő értéket fogja használni.
A GZIP (vagy AUTO gzip felismerése esetén) 32 kilobájtot fog használni (a wbits 15-re állításának megfelelően).

Az ablakméretre, a zlib és gzip streamekre vonatkozó további információkért lásd az ablakméret alábbi megjegyzéseit.

Ha a close értéke True, akkor az alapul szolgáló stream automatikusan bezáródik, amikor a deflate.DeflateIO stream bezárul. Ez akkor hasznos, ha egy másik streamet becsomagoló deflate.DeflateIO streamet szeretnél visszaadni anélkül, hogy a hívónak ismernie kellene az alapul szolgáló stream kezelését.

Ha a tömörítés engedélyezve van, egy adott deflate.DeflateIO példány egyszerre támogatja az olvasást és az írást is. Például egy kétirányú stream, mint egy socket, becsomagolható, ami mindkét irányban lehetővé teszi a tömörítést/kicsomagolást.

Konstansok¶

A négy format konstans a nyers deflate bitfolyam köré alkalmazott keretezést választja ki.

deflate.AUTO: int¶: Kicsomagoláshoz automatikusan felismeri a bemeneti formátumot a stream első bájtjainak vizsgálatával (zlib vagy gzip). Tömörítéshez fejléc vagy záró rész nélküli nyers deflate streamet generál (egyenértékű a RAW használatával).

deflate.RAW: int¶: Egy nyers deflate stream (fejléc, záró rész és ellenőrzőösszeg nélkül). Mivel a stream nem tartalmaz metaadatot, a kicsomagoló nem tudja visszanyerni az ablakméretet az adatból, ezért a wbits értékét kicsomagoláskor kifejezetten be kell állítani – különben az alapértelmezett 256 bájtos ablak túl kicsi lehet.

deflate.ZLIB: int¶: Egy zlib-be csomagolt deflate stream, az RFC 1950 szerint definiálva: egy 2 bájtos fejléc, amely rögzíti az ablakméretet, a deflate hasznos adat, és egy záró Adler-32 ellenőrzőösszeg. Kompakt és önleíró; jól alkalmas beágyazott felhasználásra.

deflate.GZIP: int¶: Egy gzip-be csomagolt deflate stream, az RFC 1952 szerint definiálva: egy fejléc opcionális fájlnév/időbélyeg metaadatokkal, a deflate hasznos adat, és egy záró CRC-32 plusz a kicsomagolt hossz. Ezt a formátumot állítja elő a gzip parancssori eszköz és a gzip.GzipFile. A fejléc nem rögzíti az ablakméretet, ezért a kicsomagolónak 32 KiB-ot kell feltételeznie, hacsak a wbits nincs beállítva.

Példák¶

A deflate.DeflateIO tipikus felhasználási esete egy tömörített fájl olvasása vagy írása a tárolóból:

import deflate

# Writing a zlib-compressed stream (uses the default window size of 256 bytes).
with open("data.z", "wb") as f:
    with deflate.DeflateIO(f, deflate.ZLIB) as d:
        # Use d.write(...) etc

# Reading a zlib-compressed stream (auto-detect window size).
with open("data.z", "rb") as f:
    with deflate.DeflateIO(f, deflate.ZLIB) as d:
        # Use d.read(), d.readinto(), etc.

Mivel a deflate.DeflateIO egy stream, használható például a json.dump() és a json.load() metódusokkal (és bárhol máshol, ahol streamek használhatók):

import deflate, json

# Write a dictionary as JSON in gzip format, with a
# small (64 byte) window size.
config = { ... }
with open("config.gz", "wb") as f:
    with deflate.DeflateIO(f, deflate.GZIP, 6) as f:
        json.dump(config, f)

# Read back that dictionary.
with open("config.gz", "rb") as f:
    with deflate.DeflateIO(f, deflate.GZIP, 6) as f:
        config = json.load(f)

Ha a forrásadataid nincsenek stream formátumban, az io.BytesIO segítségével a deflate.DeflateIO használatára alkalmas streammé alakíthatod őket:

import deflate, io

# Decompress a bytes/bytearray value.
compressed_data = get_data_z()
with deflate.DeflateIO(io.BytesIO(compressed_data), deflate.ZLIB) as d:
    decompressed_data = d.read()

# Compress a bytes/bytearray value.
uncompressed_data = get_data()
stream = io.BytesIO()
with deflate.DeflateIO(stream, deflate.ZLIB) as d:
    d.write(uncompressed_data)
compressed_data = stream.getvalue()

Deflate ablakméret¶

Az ablakméret korlátozza, hogy a (ki)tömörítő milyen messzire hivatkozhat vissza a streamben. Az ablakméret növelése javítja a tömörítést, de több memóriát igényel, és lassítja a tömörítőt.

Ha egy bemeneti streamet egy adott ablakmérettel tömörítettek, akkor egy kisebb ablakméretet használó DeflateIO a kicsomagolás közepén OSError kivétellel meghiúsul, de csak akkor, ha egy visszahivatkozás valóban messzebbre mutat, mint a kicsomagoló ablakmérete. Ez azt jelenti, hogy lehetséges lehet kisebb ablakmérettel kicsomagolni. Például ez triviálisan így lenne, ha az eredeti kicsomagolt adat rövidebb, mint az ablakméret.

Kicsomagolás¶

A zlib formátum tartalmaz egy fejlécet, amely megadja az adat tömörítéséhez használt ablakméretet. Ez jelzi a stream kicsomagolásához szükséges maximális ablakméretet. Ha ez a fejlécérték kisebb a megadott wbits értéknél (vagy ha a wbits nincs beállítva), akkor a fejlécértéket használja.

A gzip formátum nem tartalmazza az ablakméretet a fejlécben, és azt feltételezi, hogy minden gzip tömörítő (pl. a gzip segédprogram vagy a CPython gzip.GzipFile megvalósítása) a maximális, 32 KiB-os ablakméretet használja. Ezért, ha a wbits paraméter nincs beállítva, a kicsomagoló 32 KiB-os ablakméretet fog használni (a wbits 15-re állításának megfelelően). Ez azt jelenti, hogy egy tetszőleges gzip stream kicsomagolásához legalább ennyi RAM-nak rendelkezésre kell állnia. Ha te uralod a forrásadatot, fontold meg inkább a zlib formátum használatát kisebb ablakmérettel.

A nyers formátumnak nincs fejléce, ezért semmilyen információt nem tartalmaz az ablakméretről. Ha a wbits nincs beállítva, akkor alapértelmezetten 256 bájtos ablakméretet használ, ami egy adott streamhez lehet, hogy nem elég nagy. Ezért ajánlott a wbits értékét mindig kifejezetten beállítani, ha a nyers formátumot használod.

Tömörítés¶

Tömörítéshez a MicroPython minden formátum esetén alapértelmezetten 256 bájtos ablakméretet használ. Ez ésszerű mértékű tömörítést biztosít minimális memóriahasználattal és gyors tömörítési idővel, és olyan kimenetet generál, amely bármely kicsomagolóval működik.

deflate — deflate tömörítés és kicsomagolás¶