Python: gonfler et dégonfler les implémentations

Maintenant, je sais qu'il y a un Dégonfler la mise en œuvre disponible (Pyflate), mais je ne sais pas d'un Gonfler la mise en œuvre.

il semble qu'il y ait quelques options:

1. trouver une implémentation existante (idéale) de Inflate et Deflate en Python
2. écrire ma propre extension Python à la bibliothèque zlib c qui inclut Inflate et Deflate
3. appeler autre chose qui peut être exécuté à partir de la ligne de commande (comme un script Ruby, depuis Inflate / Deflate les appels en zlib sont entièrement enveloppés dans Ruby)
4. ?

je cherche un solution, mais sans que une solution, je vous en sera reconnaissant, idées, opinions constructives, et des idées.

informations supplémentaires : Le résultat de la déflation (et l'encodage d'une chaîne doit, pour l'application dont j'ai besoin, donne le même résultat que l'extrait suivant du code C#, où le paramètre d'entrée est un tableau d'octets UTF correspondant aux données à compresser:

public static string DeflateAndEncodeBase64(byte[] data)
{
    if (null == data || data.Length < 1) return null;
    string compressedBase64 = "";

    //write into a new memory stream wrapped by a deflate stream
    using (MemoryStream ms = new MemoryStream())
    {
        using (DeflateStream deflateStream = new DeflateStream(ms, CompressionMode.Compress, true))
        {
            //write byte buffer into memorystream
            deflateStream.Write(data, 0, data.Length);
            deflateStream.Close();

            //rewind memory stream and write to base 64 string
            byte[] compressedBytes = new byte[ms.Length];
            ms.Seek(0, SeekOrigin.Begin);
            ms.Read(compressedBytes, 0, (int)ms.Length);
            compressedBase64 = Convert.ToBase64String(compressedBytes);
        }
    }
    return compressedBase64;
}

exécutant ce code .NET pour la chaîne "deflate et encodez moi "donne le résultat

7b0HYBxJliUmL23Ke39K9UrX4HShCIBgEyTYkEAQ7MGIzeaS7B1pRyMpqyqBymVWZV1mFkDM7Z28995777333nvvvfe6O51OJ/ff/z9cZmQBbPbOStrJniGAqsgfP358Hz8iZvl5mbV5mi1nab6cVrM8XeT/Dw==

quand "deflate and encode me" est exécuté à travers le zlib de Python.compress () puis base64 encodé, le résultat est " eJxLSU3LSSxJVUjMS1FIzUvOT0lVyE0Fafxhb6k=".

il est clair que zlib.compress() n'est pas une implémentation du même algorithme que L'algorithme Deflate standard.

Plus D'Information :

les 2 premiers octets de les données déflatées du réseau ("7b0HY..."), après le décodage b64 sont 0xEDBD, qui ne correspond pas aux données Gzip (0x1f8b), bzip2 (0x425A) ou Zlib (0x789C).

les 2 premiers octets des données compressées Python ("eJxLS..."), après B64 décodage sont 0x789C. C'est un en-tête Zlib.

résolu

pour gérer le dégonflé brut et gonfler, sans en-tête et checksum, les choses suivantes nécessaires pour arriver:

Sur dégonfler/compress: bande les deux premiers octets (en-tête) et les quatre derniers octets (somme de contrôle).

sur gonfler/décompresser: il y a un deuxième argument pour la taille de la fenêtre. Si cette valeur est négative, elle supprime les en-têtes. voici mes méthodes actuellement, y compris l'encodage/décodage base64-et fonctionne correctement:

import zlib
import base64

def decode_base64_and_inflate( b64string ):
    decoded_data = base64.b64decode( b64string )
    return zlib.decompress( decoded_data , -15)

def deflate_and_base64_encode( string_val ):
    zlibbed_str = zlib.compress( string_val )
    compressed_string = zlibbed_str[2:-4]
    return base64.b64encode( compressed_string )