Guido van Rossum | 4b8c6ea | 2000-02-04 15:39:30 +0000 | [diff] [blame] | 1 | """Functions that read and write gzipped files. |
| 2 | |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 3 | The user of the file doesn't have to worry about the compression, |
| 4 | but random access is not allowed.""" |
| 5 | |
| 6 | # based on Andrew Kuchling's minigzip.py distributed with the zlib module |
| 7 | |
Lars Gustäbel | 1440df2 | 2009-10-29 09:39:47 +0000 | [diff] [blame] | 8 | import struct, sys, time, os |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 9 | import zlib |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 10 | import builtins |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 11 | import io |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 12 | import _compression |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 13 | |
Antoine Pitrou | 79c5ef1 | 2010-08-17 21:10:05 +0000 | [diff] [blame] | 14 | __all__ = ["GzipFile", "open", "compress", "decompress"] |
Skip Montanaro | 2dd4276 | 2001-01-23 15:35:05 +0000 | [diff] [blame] | 15 | |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 16 | FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT = 1, 2, 4, 8, 16 |
| 17 | |
| 18 | READ, WRITE = 1, 2 |
| 19 | |
Nadeem Vawda | 7e12620 | 2012-05-06 15:04:01 +0200 | [diff] [blame] | 20 | def open(filename, mode="rb", compresslevel=9, |
| 21 | encoding=None, errors=None, newline=None): |
| 22 | """Open a gzip-compressed file in binary or text mode. |
| 23 | |
Nadeem Vawda | 6872101 | 2012-06-04 23:21:38 +0200 | [diff] [blame] | 24 | The filename argument can be an actual filename (a str or bytes object), or |
| 25 | an existing file object to read from or write to. |
| 26 | |
Nadeem Vawda | ee1be99 | 2013-10-19 00:11:13 +0200 | [diff] [blame] | 27 | The mode argument can be "r", "rb", "w", "wb", "x", "xb", "a" or "ab" for |
| 28 | binary mode, or "rt", "wt", "xt" or "at" for text mode. The default mode is |
| 29 | "rb", and the default compresslevel is 9. |
Nadeem Vawda | 7e12620 | 2012-05-06 15:04:01 +0200 | [diff] [blame] | 30 | |
| 31 | For binary mode, this function is equivalent to the GzipFile constructor: |
| 32 | GzipFile(filename, mode, compresslevel). In this case, the encoding, errors |
| 33 | and newline arguments must not be provided. |
| 34 | |
| 35 | For text mode, a GzipFile object is created, and wrapped in an |
| 36 | io.TextIOWrapper instance with the specified encoding, error handling |
| 37 | behavior, and line ending(s). |
| 38 | |
| 39 | """ |
| 40 | if "t" in mode: |
| 41 | if "b" in mode: |
| 42 | raise ValueError("Invalid mode: %r" % (mode,)) |
| 43 | else: |
| 44 | if encoding is not None: |
| 45 | raise ValueError("Argument 'encoding' not supported in binary mode") |
| 46 | if errors is not None: |
| 47 | raise ValueError("Argument 'errors' not supported in binary mode") |
| 48 | if newline is not None: |
| 49 | raise ValueError("Argument 'newline' not supported in binary mode") |
Nadeem Vawda | 6872101 | 2012-06-04 23:21:38 +0200 | [diff] [blame] | 50 | |
| 51 | gz_mode = mode.replace("t", "") |
| 52 | if isinstance(filename, (str, bytes)): |
| 53 | binary_file = GzipFile(filename, gz_mode, compresslevel) |
| 54 | elif hasattr(filename, "read") or hasattr(filename, "write"): |
| 55 | binary_file = GzipFile(None, gz_mode, compresslevel, filename) |
| 56 | else: |
| 57 | raise TypeError("filename must be a str or bytes object, or a file") |
| 58 | |
Nadeem Vawda | 7e12620 | 2012-05-06 15:04:01 +0200 | [diff] [blame] | 59 | if "t" in mode: |
| 60 | return io.TextIOWrapper(binary_file, encoding, errors, newline) |
| 61 | else: |
| 62 | return binary_file |
| 63 | |
Guido van Rossum | 95bdd0b | 1999-04-12 14:34:16 +0000 | [diff] [blame] | 64 | def write32u(output, value): |
Tim Peters | fb0ea52 | 2002-11-04 19:50:11 +0000 | [diff] [blame] | 65 | # The L format writes the bit pattern correctly whether signed |
| 66 | # or unsigned. |
Guido van Rossum | 95bdd0b | 1999-04-12 14:34:16 +0000 | [diff] [blame] | 67 | output.write(struct.pack("<L", value)) |
| 68 | |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 69 | class _PaddedFile: |
| 70 | """Minimal read-only file object that prepends a string to the contents |
| 71 | of an actual file. Shouldn't be used outside of gzip.py, as it lacks |
| 72 | essential functionality.""" |
| 73 | |
| 74 | def __init__(self, f, prepend=b''): |
| 75 | self._buffer = prepend |
| 76 | self._length = len(prepend) |
| 77 | self.file = f |
| 78 | self._read = 0 |
| 79 | |
| 80 | def read(self, size): |
| 81 | if self._read is None: |
| 82 | return self.file.read(size) |
| 83 | if self._read + size <= self._length: |
| 84 | read = self._read |
| 85 | self._read += size |
| 86 | return self._buffer[read:self._read] |
| 87 | else: |
| 88 | read = self._read |
| 89 | self._read = None |
| 90 | return self._buffer[read:] + \ |
| 91 | self.file.read(size-self._length+read) |
| 92 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 93 | def prepend(self, prepend=b''): |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 94 | if self._read is None: |
| 95 | self._buffer = prepend |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 96 | else: # Assume data was read since the last prepend() call |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 97 | self._read -= len(prepend) |
| 98 | return |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 99 | self._length = len(self._buffer) |
| 100 | self._read = 0 |
| 101 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 102 | def seek(self, off): |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 103 | self._read = None |
| 104 | self._buffer = None |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 105 | return self.file.seek(off) |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 106 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 107 | def seekable(self): |
| 108 | return True # Allows fast-forwarding even in unseekable streams |
Antoine Pitrou | 7b96984 | 2010-09-23 16:22:51 +0000 | [diff] [blame] | 109 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 110 | class GzipFile(_compression.BaseStream): |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 111 | """The GzipFile class simulates most of the methods of a file object with |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 112 | the exception of the truncate() method. |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 113 | |
Nadeem Vawda | 30d94b7 | 2012-02-11 23:45:10 +0200 | [diff] [blame] | 114 | This class only supports opening files in binary mode. If you need to open a |
Nadeem Vawda | 83a4dd3 | 2012-06-30 13:34:28 +0200 | [diff] [blame] | 115 | compressed file in text mode, use the gzip.open() function. |
Nadeem Vawda | 30d94b7 | 2012-02-11 23:45:10 +0200 | [diff] [blame] | 116 | |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 117 | """ |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 118 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 119 | # Overridden with internal file object to be closed, if only a filename |
| 120 | # is passed in |
Guido van Rossum | 68de379 | 1997-07-19 20:22:23 +0000 | [diff] [blame] | 121 | myfileobj = None |
| 122 | |
Tim Peters | 07e99cb | 2001-01-14 23:47:14 +0000 | [diff] [blame] | 123 | def __init__(self, filename=None, mode=None, |
Antoine Pitrou | 42db3ef | 2009-01-04 21:37:59 +0000 | [diff] [blame] | 124 | compresslevel=9, fileobj=None, mtime=None): |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 125 | """Constructor for the GzipFile class. |
| 126 | |
| 127 | At least one of fileobj and filename must be given a |
| 128 | non-trivial value. |
| 129 | |
| 130 | The new class instance is based on fileobj, which can be a regular |
Serhiy Storchaka | 50254c5 | 2013-08-29 11:35:43 +0300 | [diff] [blame] | 131 | file, an io.BytesIO object, or any other object which simulates a file. |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 132 | It defaults to None, in which case filename is opened to provide |
| 133 | a file object. |
| 134 | |
| 135 | When fileobj is not None, the filename argument is only used to be |
| 136 | included in the gzip file header, which may includes the original |
| 137 | filename of the uncompressed file. It defaults to the filename of |
| 138 | fileobj, if discernible; otherwise, it defaults to the empty string, |
| 139 | and in this case the original filename is not included in the header. |
| 140 | |
Nadeem Vawda | ee1be99 | 2013-10-19 00:11:13 +0200 | [diff] [blame] | 141 | The mode argument can be any of 'r', 'rb', 'a', 'ab', 'w', 'wb', 'x', or |
| 142 | 'xb' depending on whether the file will be read or written. The default |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 143 | is the mode of fileobj if discernible; otherwise, the default is 'rb'. |
Nadeem Vawda | 30d94b7 | 2012-02-11 23:45:10 +0200 | [diff] [blame] | 144 | A mode of 'r' is equivalent to one of 'rb', and similarly for 'w' and |
Nadeem Vawda | ee1be99 | 2013-10-19 00:11:13 +0200 | [diff] [blame] | 145 | 'wb', 'a' and 'ab', and 'x' and 'xb'. |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 146 | |
Nadeem Vawda | 19e568d | 2012-11-11 14:04:14 +0100 | [diff] [blame] | 147 | The compresslevel argument is an integer from 0 to 9 controlling the |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 148 | level of compression; 1 is fastest and produces the least compression, |
Nadeem Vawda | 19e568d | 2012-11-11 14:04:14 +0100 | [diff] [blame] | 149 | and 9 is slowest and produces the most compression. 0 is no compression |
| 150 | at all. The default is 9. |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 151 | |
Antoine Pitrou | 42db3ef | 2009-01-04 21:37:59 +0000 | [diff] [blame] | 152 | The mtime argument is an optional numeric timestamp to be written |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 153 | to the last modification time field in the stream when compressing. |
| 154 | If omitted or None, the current time is used. |
Antoine Pitrou | 42db3ef | 2009-01-04 21:37:59 +0000 | [diff] [blame] | 155 | |
Raymond Hettinger | aef22fb | 2002-05-29 16:18:42 +0000 | [diff] [blame] | 156 | """ |
| 157 | |
Nadeem Vawda | 30d94b7 | 2012-02-11 23:45:10 +0200 | [diff] [blame] | 158 | if mode and ('t' in mode or 'U' in mode): |
Nadeem Vawda | be66af4 | 2012-02-12 00:06:02 +0200 | [diff] [blame] | 159 | raise ValueError("Invalid mode: {!r}".format(mode)) |
Skip Montanaro | 12424bc | 2002-05-23 01:43:05 +0000 | [diff] [blame] | 160 | if mode and 'b' not in mode: |
| 161 | mode += 'b' |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 162 | if fileobj is None: |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 163 | fileobj = self.myfileobj = builtins.open(filename, mode or 'rb') |
Guido van Rossum | 68de379 | 1997-07-19 20:22:23 +0000 | [diff] [blame] | 164 | if filename is None: |
Nadeem Vawda | 103e811 | 2012-06-20 01:35:22 +0200 | [diff] [blame] | 165 | filename = getattr(fileobj, 'name', '') |
| 166 | if not isinstance(filename, (str, bytes)): |
Nadeem Vawda | 892b0b9 | 2012-01-18 09:25:58 +0200 | [diff] [blame] | 167 | filename = '' |
Guido van Rossum | 68de379 | 1997-07-19 20:22:23 +0000 | [diff] [blame] | 168 | if mode is None: |
Nadeem Vawda | be66af4 | 2012-02-12 00:06:02 +0200 | [diff] [blame] | 169 | mode = getattr(fileobj, 'mode', 'rb') |
Guido van Rossum | 68de379 | 1997-07-19 20:22:23 +0000 | [diff] [blame] | 170 | |
Nadeem Vawda | be66af4 | 2012-02-12 00:06:02 +0200 | [diff] [blame] | 171 | if mode.startswith('r'): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 172 | self.mode = READ |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 173 | raw = _GzipReader(fileobj) |
| 174 | self._buffer = io.BufferedReader(raw) |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 175 | self.name = filename |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 176 | |
Nadeem Vawda | ee1be99 | 2013-10-19 00:11:13 +0200 | [diff] [blame] | 177 | elif mode.startswith(('w', 'a', 'x')): |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 178 | self.mode = WRITE |
| 179 | self._init_write(filename) |
| 180 | self.compress = zlib.compressobj(compresslevel, |
Tim Peters | 07e99cb | 2001-01-14 23:47:14 +0000 | [diff] [blame] | 181 | zlib.DEFLATED, |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 182 | -zlib.MAX_WBITS, |
| 183 | zlib.DEF_MEM_LEVEL, |
| 184 | 0) |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 185 | self._write_mtime = mtime |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 186 | else: |
Nadeem Vawda | be66af4 | 2012-02-12 00:06:02 +0200 | [diff] [blame] | 187 | raise ValueError("Invalid mode: {!r}".format(mode)) |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 188 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 189 | self.fileobj = fileobj |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 190 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 191 | if self.mode == WRITE: |
| 192 | self._write_gzip_header() |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 193 | |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 194 | @property |
| 195 | def filename(self): |
| 196 | import warnings |
Philip Jenvey | a394f2d | 2009-05-08 03:57:12 +0000 | [diff] [blame] | 197 | warnings.warn("use the name attribute", DeprecationWarning, 2) |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 198 | if self.mode == WRITE and self.name[-3:] != ".gz": |
| 199 | return self.name + ".gz" |
| 200 | return self.name |
| 201 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 202 | @property |
| 203 | def mtime(self): |
| 204 | """Last modification time read from stream, or None""" |
| 205 | return self._buffer.raw._last_mtime |
| 206 | |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 207 | def __repr__(self): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 208 | s = repr(self.fileobj) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 209 | return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>' |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 210 | |
| 211 | def _init_write(self, filename): |
Thomas Wouters | cf297e4 | 2007-02-23 15:07:44 +0000 | [diff] [blame] | 212 | self.name = filename |
Martin Panter | b82032f | 2015-12-11 05:19:29 +0000 | [diff] [blame] | 213 | self.crc = zlib.crc32(b"") |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 214 | self.size = 0 |
| 215 | self.writebuf = [] |
| 216 | self.bufsize = 0 |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 217 | self.offset = 0 # Current file offset for seek(), tell(), etc |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 218 | |
| 219 | def _write_gzip_header(self): |
Walter Dörwald | 5b1284d | 2007-06-06 16:43:59 +0000 | [diff] [blame] | 220 | self.fileobj.write(b'\037\213') # magic header |
| 221 | self.fileobj.write(b'\010') # compression method |
Lars Gustäbel | 5590d8c | 2007-08-10 12:02:32 +0000 | [diff] [blame] | 222 | try: |
Lars Gustäbel | ead7056 | 2007-08-13 09:05:16 +0000 | [diff] [blame] | 223 | # RFC 1952 requires the FNAME field to be Latin-1. Do not |
| 224 | # include filenames that cannot be represented that way. |
Lars Gustäbel | 1440df2 | 2009-10-29 09:39:47 +0000 | [diff] [blame] | 225 | fname = os.path.basename(self.name) |
Nadeem Vawda | 103e811 | 2012-06-20 01:35:22 +0200 | [diff] [blame] | 226 | if not isinstance(fname, bytes): |
| 227 | fname = fname.encode('latin-1') |
Lars Gustäbel | ead7056 | 2007-08-13 09:05:16 +0000 | [diff] [blame] | 228 | if fname.endswith(b'.gz'): |
| 229 | fname = fname[:-3] |
Lars Gustäbel | 5590d8c | 2007-08-10 12:02:32 +0000 | [diff] [blame] | 230 | except UnicodeEncodeError: |
Lars Gustäbel | ead7056 | 2007-08-13 09:05:16 +0000 | [diff] [blame] | 231 | fname = b'' |
| 232 | flags = 0 |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 233 | if fname: |
| 234 | flags = FNAME |
Walter Dörwald | 5b1284d | 2007-06-06 16:43:59 +0000 | [diff] [blame] | 235 | self.fileobj.write(chr(flags).encode('latin-1')) |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 236 | mtime = self._write_mtime |
Antoine Pitrou | 42db3ef | 2009-01-04 21:37:59 +0000 | [diff] [blame] | 237 | if mtime is None: |
| 238 | mtime = time.time() |
| 239 | write32u(self.fileobj, int(mtime)) |
Walter Dörwald | 5b1284d | 2007-06-06 16:43:59 +0000 | [diff] [blame] | 240 | self.fileobj.write(b'\002') |
| 241 | self.fileobj.write(b'\377') |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 242 | if fname: |
Lars Gustäbel | 5590d8c | 2007-08-10 12:02:32 +0000 | [diff] [blame] | 243 | self.fileobj.write(fname + b'\000') |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 244 | |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 245 | def write(self,data): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 246 | self._check_not_closed() |
Martin v. Löwis | db04489 | 2002-03-11 06:46:52 +0000 | [diff] [blame] | 247 | if self.mode != WRITE: |
| 248 | import errno |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 249 | raise OSError(errno.EBADF, "write() on read-only GzipFile object") |
Tim Peters | 863ac44 | 2002-04-16 01:38:40 +0000 | [diff] [blame] | 250 | |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 251 | if self.fileobj is None: |
Collin Winter | ce36ad8 | 2007-08-30 01:19:48 +0000 | [diff] [blame] | 252 | raise ValueError("write() on closed GzipFile object") |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 253 | |
Serhiy Storchaka | bca63b3 | 2015-03-23 14:59:48 +0200 | [diff] [blame] | 254 | if isinstance(data, bytes): |
| 255 | length = len(data) |
| 256 | else: |
| 257 | # accept any data that supports the buffer protocol |
| 258 | data = memoryview(data) |
| 259 | length = data.nbytes |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 260 | |
Serhiy Storchaka | bca63b3 | 2015-03-23 14:59:48 +0200 | [diff] [blame] | 261 | if length > 0: |
| 262 | self.fileobj.write(self.compress.compress(data)) |
| 263 | self.size += length |
Martin Panter | b82032f | 2015-12-11 05:19:29 +0000 | [diff] [blame] | 264 | self.crc = zlib.crc32(data, self.crc) |
Serhiy Storchaka | bca63b3 | 2015-03-23 14:59:48 +0200 | [diff] [blame] | 265 | self.offset += length |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 266 | |
Serhiy Storchaka | bca63b3 | 2015-03-23 14:59:48 +0200 | [diff] [blame] | 267 | return length |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 268 | |
Guido van Rossum | 5606801 | 2000-02-02 16:51:06 +0000 | [diff] [blame] | 269 | def read(self, size=-1): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 270 | self._check_not_closed() |
Martin v. Löwis | db04489 | 2002-03-11 06:46:52 +0000 | [diff] [blame] | 271 | if self.mode != READ: |
| 272 | import errno |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 273 | raise OSError(errno.EBADF, "read() on write-only GzipFile object") |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 274 | return self._buffer.read(size) |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 275 | |
Antoine Pitrou | 4ec4b0c | 2011-04-04 21:00:37 +0200 | [diff] [blame] | 276 | def read1(self, size=-1): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 277 | """Implements BufferedIOBase.read1() |
| 278 | |
| 279 | Reads up to a buffer's worth of data is size is negative.""" |
| 280 | self._check_not_closed() |
Antoine Pitrou | 4ec4b0c | 2011-04-04 21:00:37 +0200 | [diff] [blame] | 281 | if self.mode != READ: |
| 282 | import errno |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 283 | raise OSError(errno.EBADF, "read1() on write-only GzipFile object") |
Antoine Pitrou | 4ec4b0c | 2011-04-04 21:00:37 +0200 | [diff] [blame] | 284 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 285 | if size < 0: |
| 286 | size = io.DEFAULT_BUFFER_SIZE |
| 287 | return self._buffer.read1(size) |
Antoine Pitrou | 4ec4b0c | 2011-04-04 21:00:37 +0200 | [diff] [blame] | 288 | |
Antoine Pitrou | c3ed2e7 | 2010-09-29 10:49:46 +0000 | [diff] [blame] | 289 | def peek(self, n): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 290 | self._check_not_closed() |
Antoine Pitrou | c3ed2e7 | 2010-09-29 10:49:46 +0000 | [diff] [blame] | 291 | if self.mode != READ: |
| 292 | import errno |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 293 | raise OSError(errno.EBADF, "peek() on write-only GzipFile object") |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 294 | return self._buffer.peek(n) |
Antoine Pitrou | 8e33fd7 | 2010-01-13 14:37:26 +0000 | [diff] [blame] | 295 | |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 296 | @property |
| 297 | def closed(self): |
| 298 | return self.fileobj is None |
| 299 | |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 300 | def close(self): |
Serhiy Storchaka | 7e7a3db | 2015-04-10 13:24:41 +0300 | [diff] [blame] | 301 | fileobj = self.fileobj |
| 302 | if fileobj is None: |
Georg Brandl | b533e26 | 2008-05-25 18:19:30 +0000 | [diff] [blame] | 303 | return |
Serhiy Storchaka | 7e7a3db | 2015-04-10 13:24:41 +0300 | [diff] [blame] | 304 | self.fileobj = None |
| 305 | try: |
| 306 | if self.mode == WRITE: |
| 307 | fileobj.write(self.compress.flush()) |
| 308 | write32u(fileobj, self.crc) |
| 309 | # self.size may exceed 2GB, or even 4GB |
| 310 | write32u(fileobj, self.size & 0xffffffff) |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 311 | elif self.mode == READ: |
| 312 | self._buffer.close() |
Serhiy Storchaka | 7e7a3db | 2015-04-10 13:24:41 +0300 | [diff] [blame] | 313 | finally: |
| 314 | myfileobj = self.myfileobj |
| 315 | if myfileobj: |
| 316 | self.myfileobj = None |
| 317 | myfileobj.close() |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 318 | |
Martin v. Löwis | f2a8d63 | 2005-03-03 08:35:22 +0000 | [diff] [blame] | 319 | def flush(self,zlib_mode=zlib.Z_SYNC_FLUSH): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 320 | self._check_not_closed() |
Martin v. Löwis | f2a8d63 | 2005-03-03 08:35:22 +0000 | [diff] [blame] | 321 | if self.mode == WRITE: |
Tim Peters | eba28be | 2005-03-28 01:08:02 +0000 | [diff] [blame] | 322 | # Ensure the compressor's buffer is flushed |
| 323 | self.fileobj.write(self.compress.flush(zlib_mode)) |
Mark Dickinson | a9eb87a | 2010-05-04 18:47:04 +0000 | [diff] [blame] | 324 | self.fileobj.flush() |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 325 | |
Tim Peters | 5cfb05e | 2004-07-27 21:02:02 +0000 | [diff] [blame] | 326 | def fileno(self): |
| 327 | """Invoke the underlying file object's fileno() method. |
| 328 | |
| 329 | This will raise AttributeError if the underlying file object |
| 330 | doesn't support fileno(). |
| 331 | """ |
| 332 | return self.fileobj.fileno() |
| 333 | |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 334 | def rewind(self): |
| 335 | '''Return the uncompressed stream file position indicator to the |
Tim Peters | ab9ba27 | 2001-08-09 21:40:30 +0000 | [diff] [blame] | 336 | beginning of the file''' |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 337 | if self.mode != READ: |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 338 | raise OSError("Can't rewind in write mode") |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 339 | self._buffer.seek(0) |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 340 | |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 341 | def readable(self): |
| 342 | return self.mode == READ |
| 343 | |
| 344 | def writable(self): |
| 345 | return self.mode == WRITE |
| 346 | |
| 347 | def seekable(self): |
| 348 | return True |
| 349 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 350 | def seek(self, offset, whence=io.SEEK_SET): |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 351 | if self.mode == WRITE: |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 352 | if whence != io.SEEK_SET: |
| 353 | if whence == io.SEEK_CUR: |
| 354 | offset = self.offset + offset |
| 355 | else: |
| 356 | raise ValueError('Seek from end not supported') |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 357 | if offset < self.offset: |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 358 | raise OSError('Negative seek in write mode') |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 359 | count = offset - self.offset |
Walter Dörwald | 5b1284d | 2007-06-06 16:43:59 +0000 | [diff] [blame] | 360 | chunk = bytes(1024) |
Tim Peters | fb0ea52 | 2002-11-04 19:50:11 +0000 | [diff] [blame] | 361 | for i in range(count // 1024): |
Walter Dörwald | 5b1284d | 2007-06-06 16:43:59 +0000 | [diff] [blame] | 362 | self.write(chunk) |
| 363 | self.write(bytes(count % 1024)) |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 364 | elif self.mode == READ: |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 365 | self._check_not_closed() |
| 366 | return self._buffer.seek(offset, whence) |
Martin v. Löwis | 8cc965c | 2001-08-09 07:21:56 +0000 | [diff] [blame] | 367 | |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 368 | return self.offset |
| 369 | |
Andrew M. Kuchling | 41616ee | 2000-07-29 20:15:26 +0000 | [diff] [blame] | 370 | def readline(self, size=-1): |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 371 | self._check_not_closed() |
| 372 | return self._buffer.readline(size) |
| 373 | |
| 374 | |
| 375 | class _GzipReader(_compression.DecompressReader): |
| 376 | def __init__(self, fp): |
| 377 | super().__init__(_PaddedFile(fp), zlib.decompressobj, |
| 378 | wbits=-zlib.MAX_WBITS) |
| 379 | # Set flag indicating start of a new member |
| 380 | self._new_member = True |
| 381 | self._last_mtime = None |
| 382 | |
| 383 | def _init_read(self): |
Martin Panter | b82032f | 2015-12-11 05:19:29 +0000 | [diff] [blame] | 384 | self._crc = zlib.crc32(b"") |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 385 | self._stream_size = 0 # Decompressed size of unconcatenated stream |
| 386 | |
| 387 | def _read_exact(self, n): |
| 388 | '''Read exactly *n* bytes from `self._fp` |
| 389 | |
| 390 | This method is required because self._fp may be unbuffered, |
| 391 | i.e. return short reads. |
| 392 | ''' |
| 393 | |
| 394 | data = self._fp.read(n) |
| 395 | while len(data) < n: |
| 396 | b = self._fp.read(n - len(data)) |
| 397 | if not b: |
| 398 | raise EOFError("Compressed file ended before the " |
| 399 | "end-of-stream marker was reached") |
| 400 | data += b |
| 401 | return data |
| 402 | |
| 403 | def _read_gzip_header(self): |
| 404 | magic = self._fp.read(2) |
| 405 | if magic == b'': |
| 406 | return False |
| 407 | |
| 408 | if magic != b'\037\213': |
| 409 | raise OSError('Not a gzipped file (%r)' % magic) |
| 410 | |
| 411 | (method, flag, |
| 412 | self._last_mtime) = struct.unpack("<BBIxx", self._read_exact(8)) |
| 413 | if method != 8: |
| 414 | raise OSError('Unknown compression method') |
| 415 | |
| 416 | if flag & FEXTRA: |
| 417 | # Read & discard the extra field, if present |
| 418 | extra_len, = struct.unpack("<H", self._read_exact(2)) |
| 419 | self._read_exact(extra_len) |
| 420 | if flag & FNAME: |
| 421 | # Read and discard a null-terminated string containing the filename |
| 422 | while True: |
| 423 | s = self._fp.read(1) |
| 424 | if not s or s==b'\000': |
| 425 | break |
| 426 | if flag & FCOMMENT: |
| 427 | # Read and discard a null-terminated string containing a comment |
| 428 | while True: |
| 429 | s = self._fp.read(1) |
| 430 | if not s or s==b'\000': |
| 431 | break |
| 432 | if flag & FHCRC: |
| 433 | self._read_exact(2) # Read & discard the 16-bit header CRC |
| 434 | return True |
| 435 | |
| 436 | def read(self, size=-1): |
Thomas Wouters | 477c8d5 | 2006-05-27 19:21:47 +0000 | [diff] [blame] | 437 | if size < 0: |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 438 | return self.readall() |
| 439 | # size=0 is special because decompress(max_length=0) is not supported |
| 440 | if not size: |
| 441 | return b"" |
Antoine Pitrou | b1f8835 | 2010-01-03 22:37:40 +0000 | [diff] [blame] | 442 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 443 | # For certain input data, a single |
| 444 | # call to decompress() may not return |
| 445 | # any data. In this case, retry until we get some data or reach EOF. |
| 446 | while True: |
| 447 | if self._decompressor.eof: |
| 448 | # Ending case: we've come to the end of a member in the file, |
| 449 | # so finish up this member, and read a new gzip header. |
| 450 | # Check the CRC and file size, and set the flag so we read |
| 451 | # a new member |
| 452 | self._read_eof() |
| 453 | self._new_member = True |
| 454 | self._decompressor = self._decomp_factory( |
| 455 | **self._decomp_args) |
Thomas Wouters | 477c8d5 | 2006-05-27 19:21:47 +0000 | [diff] [blame] | 456 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 457 | if self._new_member: |
| 458 | # If the _new_member flag is set, we have to |
| 459 | # jump to the next member, if there is one. |
| 460 | self._init_read() |
| 461 | if not self._read_gzip_header(): |
| 462 | self._size = self._pos |
| 463 | return b"" |
| 464 | self._new_member = False |
Guido van Rossum | 1526219 | 1997-04-30 16:04:57 +0000 | [diff] [blame] | 465 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 466 | # Read a chunk of data from the file |
| 467 | buf = self._fp.read(io.DEFAULT_BUFFER_SIZE) |
| 468 | |
| 469 | uncompress = self._decompressor.decompress(buf, size) |
| 470 | if self._decompressor.unconsumed_tail != b"": |
| 471 | self._fp.prepend(self._decompressor.unconsumed_tail) |
| 472 | elif self._decompressor.unused_data != b"": |
| 473 | # Prepend the already read bytes to the fileobj so they can |
| 474 | # be seen by _read_eof() and _read_gzip_header() |
| 475 | self._fp.prepend(self._decompressor.unused_data) |
| 476 | |
| 477 | if uncompress != b"": |
Thomas Wouters | 477c8d5 | 2006-05-27 19:21:47 +0000 | [diff] [blame] | 478 | break |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 479 | if buf == b"": |
| 480 | raise EOFError("Compressed file ended before the " |
| 481 | "end-of-stream marker was reached") |
Andrew M. Kuchling | 41616ee | 2000-07-29 20:15:26 +0000 | [diff] [blame] | 482 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 483 | self._add_read_data( uncompress ) |
| 484 | self._pos += len(uncompress) |
| 485 | return uncompress |
Tim Peters | 07e99cb | 2001-01-14 23:47:14 +0000 | [diff] [blame] | 486 | |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 487 | def _add_read_data(self, data): |
Martin Panter | b82032f | 2015-12-11 05:19:29 +0000 | [diff] [blame] | 488 | self._crc = zlib.crc32(data, self._crc) |
Antoine Pitrou | 2dbc6e6 | 2015-04-11 00:31:01 +0200 | [diff] [blame] | 489 | self._stream_size = self._stream_size + len(data) |
| 490 | |
| 491 | def _read_eof(self): |
| 492 | # We've read to the end of the file |
| 493 | # We check the that the computed CRC and size of the |
| 494 | # uncompressed data matches the stored values. Note that the size |
| 495 | # stored is the true file size mod 2**32. |
| 496 | crc32, isize = struct.unpack("<II", self._read_exact(8)) |
| 497 | if crc32 != self._crc: |
| 498 | raise OSError("CRC check failed %s != %s" % (hex(crc32), |
| 499 | hex(self._crc))) |
| 500 | elif isize != (self._stream_size & 0xffffffff): |
| 501 | raise OSError("Incorrect length of data produced") |
| 502 | |
| 503 | # Gzip files can be padded with zeroes and still have archives. |
| 504 | # Consume all zero bytes and set the file position to the first |
| 505 | # non-zero byte. See http://www.gzip.org/#faq8 |
| 506 | c = b"\x00" |
| 507 | while c == b"\x00": |
| 508 | c = self._fp.read(1) |
| 509 | if c: |
| 510 | self._fp.prepend(c) |
| 511 | |
| 512 | def _rewind(self): |
| 513 | super()._rewind() |
| 514 | self._new_member = True |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 515 | |
Antoine Pitrou | 79c5ef1 | 2010-08-17 21:10:05 +0000 | [diff] [blame] | 516 | def compress(data, compresslevel=9): |
| 517 | """Compress data in one shot and return the compressed string. |
Nadeem Vawda | 19e568d | 2012-11-11 14:04:14 +0100 | [diff] [blame] | 518 | Optional argument is the compression level, in range of 0-9. |
Antoine Pitrou | 79c5ef1 | 2010-08-17 21:10:05 +0000 | [diff] [blame] | 519 | """ |
| 520 | buf = io.BytesIO() |
| 521 | with GzipFile(fileobj=buf, mode='wb', compresslevel=compresslevel) as f: |
| 522 | f.write(data) |
| 523 | return buf.getvalue() |
| 524 | |
| 525 | def decompress(data): |
| 526 | """Decompress a gzip compressed string in one shot. |
| 527 | Return the decompressed string. |
| 528 | """ |
| 529 | with GzipFile(fileobj=io.BytesIO(data)) as f: |
| 530 | return f.read() |
| 531 | |
| 532 | |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 533 | def _test(): |
| 534 | # Act like gzip; with -d, act like gunzip. |
| 535 | # The input file is not deleted, however, nor are any other gzip |
| 536 | # options or features supported. |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 537 | args = sys.argv[1:] |
| 538 | decompress = args and args[0] == "-d" |
| 539 | if decompress: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 540 | args = args[1:] |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 541 | if not args: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 542 | args = ["-"] |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 543 | for arg in args: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 544 | if decompress: |
| 545 | if arg == "-": |
Antoine Pitrou | 9d625c2 | 2009-01-04 21:11:10 +0000 | [diff] [blame] | 546 | f = GzipFile(filename="", mode="rb", fileobj=sys.stdin.buffer) |
| 547 | g = sys.stdout.buffer |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 548 | else: |
| 549 | if arg[-3:] != ".gz": |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 550 | print("filename doesn't end in .gz:", repr(arg)) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 551 | continue |
| 552 | f = open(arg, "rb") |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 553 | g = builtins.open(arg[:-3], "wb") |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 554 | else: |
| 555 | if arg == "-": |
Antoine Pitrou | 9d625c2 | 2009-01-04 21:11:10 +0000 | [diff] [blame] | 556 | f = sys.stdin.buffer |
| 557 | g = GzipFile(filename="", mode="wb", fileobj=sys.stdout.buffer) |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 558 | else: |
Georg Brandl | 1a3284e | 2007-12-02 09:40:06 +0000 | [diff] [blame] | 559 | f = builtins.open(arg, "rb") |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 560 | g = open(arg + ".gz", "wb") |
Guido van Rossum | 8ca162f | 2002-04-07 06:36:23 +0000 | [diff] [blame] | 561 | while True: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 562 | chunk = f.read(1024) |
| 563 | if not chunk: |
| 564 | break |
| 565 | g.write(chunk) |
Antoine Pitrou | ecc4757 | 2012-08-30 00:29:24 +0200 | [diff] [blame] | 566 | if g is not sys.stdout.buffer: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 567 | g.close() |
Antoine Pitrou | ecc4757 | 2012-08-30 00:29:24 +0200 | [diff] [blame] | 568 | if f is not sys.stdin.buffer: |
Guido van Rossum | 45e2fbc | 1998-03-26 21:13:24 +0000 | [diff] [blame] | 569 | f.close() |
Guido van Rossum | 51ca6e3 | 1997-12-30 20:09:08 +0000 | [diff] [blame] | 570 | |
| 571 | if __name__ == '__main__': |
| 572 | _test() |