Python: Créer un streaming gzip avais de fichiers?

Je suis à essayer de comprendre la meilleure façon de compresser un flux de données avec Python zlib.

J'ai un fichier-comme les flux d'entrée (input, ci-dessous) et une sortie de la fonction qui accepte un fichier de type (output_function, ci-dessous):

with open("file") as input:
    output_function(input)

Et j'aimerais gzip compresse input morceaux avant de les envoyer à output_function:

with open("file") as input:
    output_function(gzip_stream(input))

Il ressemble à la gzip module suppose que l'entrée ou la sortie sera un gzip avais fichier sur le disque... Donc je suppose que le zlib module est ce que je veux.

Cependant, il n'est pas nativement offre un moyen simple de créer un fichier de flux-like... Et le flux de compression, il n'soutien vient de la façon d'ajouter manuellement des données à une compression de la mémoire tampon, puis rinçage de la mémoire tampon.

Bien sûr, je pourrais écrire un wrapper autour de zlib.Compress.compress et zlib.Compress.flush (Compress est retourné par zlib.compressobj()), mais je serais inquiet au sujet d'obtenir des tailles de mémoire tampon de mal, ou quelque chose de similaire.

Alors, quelle est la façon la plus simple de créer un streaming, gzip compression de fichiers avec Python?

Modifier: Pour clarifier, les flux d'entrée et de la compression de flux de sortie sont à la fois trop grand pour tenir dans la mémoire, donc quelque chose comme output_function(StringIO(zlib.compress(input.read()))) n'a pas vraiment résoudre le problème.

J'ai trouvé une mise en œuvre de l ' autre chose - un fichier comme décompresser un gzip avais flux à effbot: effbot.org/librarybook/zlib.htm ... Mais je suis à la recherche pour le contraire (bien que je suppose qu'il pourrait être utile si j'ai besoin d'écrire mon propre)

InformationsquelleAutor David Wolever | 2010-02-03

10

C'est assez encombrants (auto-référencement, etc; il suffit de mettre quelques minutes à l'écrire, rien de vraiment élégant), mais il fait ce que vous voulez si vous êtes toujours intéressé à l'aide de gzip au lieu de zlib directement.

Fondamentalement, GzipWrap est un (très limitée) fichier-comme l'objet qui produit un fichier au format gzip des itérable (par exemple, un fichier-comme l'objet, d'une liste de chaînes, un générateur...)

Bien sûr, il produit binaire, donc il n'y a pas de sens dans la mise en œuvre "readline".

Vous devriez être en mesure de développer pour couvrir d'autres cas, ou pour être utilisé comme un objet iterable objet lui-même.
```
from gzip import GzipFile

class GzipWrap(object):
    # input is a filelike object that feeds the input
    def __init__(self, input, filename = None):
        self.input = input
        self.buffer = ''
        self.zipper = GzipFile(filename, mode = 'wb', fileobj = self)

    def read(self, size=-1):
        if (size < 0) or len(self.buffer) < size:
            for s in self.input:
                self.zipper.write(s)
                if size > 0 and len(self.buffer) >= size:
                    self.zipper.flush()
                    break
            else:
                self.zipper.close()
            if size < 0:
                ret = self.buffer
                self.buffer = ''
        else:
            ret, self.buffer = self.buffer[:size], self.buffer[size:]
        return ret

    def flush(self):
        pass

    def write(self, data):
        self.buffer += data

    def close(self):
        self.input.close()
```
- haha très intelligent de passage de self à la GzipFile. Je l'aime!
- (ok, je vois votre point qu'il n'est pas particulièrement élégant pour passer un 'soi' à la GzipFile... Mais je pense toujours que c'est un très joli hack).
- J'ai corrigé un petit bug dans le code. Lors de la lecture avec la taille de < 0, il n'a pas effacer la mémoire tampon. Je ne pense pas que vous allez être l'utilisant comme ça, mais un bug est un bug... O:)
- pourquoi n'est-ce pas quelque chose comme cela fournies par la bibliothèque standard? A quoi bon un utilitaire gzip qui n'a pas de stream? C'est généralement le cas que l'ensemble du dossier ne rentre pas dans la mémoire (c'est le format pour une raison, après tout).
- Je suppose qu'ils ont inclus pour une utilisation en interne. N'ai pas vérifié si ça a changé au cours de la dernière année, la pensée...
- La version actuelle de cette réponse lit une ligne à la fois en mémoire. Si le fichier que vous compressez a très peu de retours à la ligne, cela peut être un problème.
InformationsquelleAutor Ricardo Cárdenes

Ici est un nettoyant non auto-référencement version basée sur Ricardo Cárdenes " très utile de répondre.

from gzip import GzipFile
from collections import deque
CHUNK = 16 * 1024
class Buffer (object):
def __init__ (self):
self.__buf = deque()
self.__size = 0
def __len__ (self):
return self.__size
def write (self, data):
self.__buf.append(data)
self.__size += len(data)
def read (self, size=-1):
if size < 0: size = self.__size
ret_list = []
while size > 0 and len(self.__buf):
s = self.__buf.popleft()
size -= len(s)
ret_list.append(s)
if size < 0:
ret_list[-1], remainder = ret_list[-1][:size], ret_list[-1][size:]
self.__buf.appendleft(remainder)
ret = ''.join(ret_list)
self.__size -= len(ret)
return ret
def flush (self):
pass
def close (self):
pass
class GzipCompressReadStream (object):
def __init__ (self, fileobj):
self.__input = fileobj
self.__buf = Buffer()
self.__gzip = GzipFile(None, mode='wb', fileobj=self.__buf)
def read (self, size=-1):
while size < 0 or len(self.__buf) < size:
s = self.__input.read(CHUNK)
if not s:
self.__gzip.close()
break
self.__gzip.write(s)
return self.__buf.read(size)

Avantages:

Permet d'éviter que plusieurs de concaténation de chaîne, qui serait la cause de la totalité de la chaîne à être copié à plusieurs reprises.
Lit fixe taille de BLOC à partir du flux d'entrée, au lieu de lire des lignes entières à un moment (qui peut être arbitrairement longue).
Évite les références circulaires.
Évite trompeuses "écrire" méthode de GzipCompressStream(), ce qui est vraiment utilisé uniquement en interne.
Prend avantage de nom d'amputation de membres internes variables.

Ne fonctionne pas sur Python 3, octets/str erreur.
Pour python 3 utilisation ret = b''.join(ret_list) au lieu de cela, et si votre flux d'entrée est une chaîne, alors vous devez coder par exemple self.__gzip.write(s.encode('utf-8')

InformationsquelleAutor Collin

4

Le gzip module prend en charge la compression d'un fichier-comme l'objet, passer une fileobj paramètre GzipFile, ainsi qu'un nom de fichier. Le nom de fichier que vous transmettez n'a pas besoin d'exister, mais l'en-tête gzip a un nom de domaine qui doit être rempli.

Mise à jour

Cette réponse ne fonctionne pas. Exemple:
```
# tmp/try-gzip.py 
import sys
import gzip
fd=gzip.GzipFile(fileobj=sys.stdin)
sys.stdout.write(fd.read())
```
de sortie:
```
===> cat .bash_history  | python tmp/try-gzip.py  > tmp/history.gzip
Traceback (most recent call last):
File "tmp/try-gzip.py", line 7, in <module>
sys.stdout.write(fd.read())
File "/usr/lib/python2.7/gzip.py", line 254, in read
self._read(readsize)
File "/usr/lib/python2.7/gzip.py", line 288, in _read
pos = self.fileobj.tell()   # Save current position
IOError: [Errno 29] Illegal seek
```
- Mmmm... je n'avais pas remarqué que... Mais je ne suis pas sûr que cela fonctionne: le fileobj doit être un gzip avais flux d'entrée ou une sortie de flux qui le gzip avais données seront écrites. Donc, c'est mieux que rien, mais pas encore tout à fait ce que je voudrais.
- Veuillez expliquer pourquoi cela ne résout pas votre problème. J'utilise fd=gzip.GzipFile(fileobj=fd) et il fonctionne comme il le devrait.
- l'auteur s'attend à ce que le fd l'objet n'a pas seek méthode.
- oui, vous avez raison. Je l'ai vérifié et modifié la réponse. J'espère user249290 n'a rien contre cela.
InformationsquelleAutor user249290
2

Utiliser le cStringIO (ou StringIO) module en conjonction avec zlib:
```
>>> import zlib
>>> from cStringIO import StringIO
>>> s.write(zlib.compress("I'm a lumberjack"))
>>> s.seek(0)
>>> zlib.decompress(s.read())
"I'm a lumberjack"
```
- Le problème avec cela, cependant, est que la totalité du flux d'entrée doit être chargé en mémoire (lorsqu'il est transmis à zlib.compress) et doit ensuite être chargé dans la mémoire nouveau quand il est retourné à partir de zlib.decompress.
- Il ne quitte jamais la mémoire, si vous utilisez StringIO. Vous avez dit dans votre question que vous vouliez un "fichier-comme objet", ce qui est commun python terminologie pour un objet qui a des méthodes similaires pour un fichier objet. Elle ne dit rien à ce sujet qu'il vit sur le disque ou non. Mais alors, vous aussi suggéré que vous ne voulez pas un fichier gz. Pouvez-vous s'il vous plaît être plus clair sur ce que vous recherchez vraiment?
- Euh, désolé - oui, c'est de ma faute. Dans mon esprit "fichier-comme objet" signifie "quelque chose destinée à être transformée en morceaux", mais je suppose que c'est une mauvaise hypothèse. J'ai mis à jour la question.
- avez-vous regardé zlib.compressobj() et zlib.decompressobj()? Parfait pour la segmentation.
- Yup, j'ai. Comme je l'ai mentionné (mais pas très clairement), ils travaillent, mais leur interface n'est pas très standard, et il pouvait compter sur mon arriver des choses comme la taille du buffer de corriger.
InformationsquelleAutor jcdyer
1

Cela fonctionne (au moins en python 3):
```
with s3.open(path, 'wb') as f:
gz = gzip.GzipFile(filename, 'wb', 9, f)
gz.write(b'hello')
gz.flush()
gz.close()
```
Ici, il écrit à s3fs de fichier de l'objet avec une compression gzip sur elle.
La magie est la f paramètre, qui est GzipFile de fileobj. Vous devez donner un nom de fichier gzip-tête.

InformationsquelleAutor user582175

Vous devez vous connecter pour publier un commentaire.