support define_macros / undef_macros in setup.cfg

Lib/lzma.py

 """Interface to the liblzma compression library.
 
 This module provides a class for reading and writing compressed files,
 classes for incremental (de)compression, and convenience functions for
 one-shot (de)compression.
 
 These classes and functions support both the XZ and legacy LZMA
 container formats, as well as raw compressed data streams.
 """
 
 __all__ = [
     "CHECK_NONE", "CHECK_CRC32", "CHECK_CRC64", "CHECK_SHA256",
     "CHECK_ID_MAX", "CHECK_UNKNOWN",
     "FILTER_LZMA1", "FILTER_LZMA2", "FILTER_DELTA", "FILTER_X86", "FILTER_IA64",
     "FILTER_ARM", "FILTER_ARMTHUMB", "FILTER_POWERPC", "FILTER_SPARC",
     "FORMAT_AUTO", "FORMAT_XZ", "FORMAT_ALONE", "FORMAT_RAW",
     "MF_HC3", "MF_HC4", "MF_BT2", "MF_BT3", "MF_BT4",
     "MODE_FAST", "MODE_NORMAL", "PRESET_DEFAULT", "PRESET_EXTREME",
 
     "LZMACompressor", "LZMADecompressor", "LZMAFile", "LZMAError",
-    "open", "compress", "decompress", "is_check_supported",
+    "compress", "decompress", "is_check_supported",
     "encode_filter_properties", "decode_filter_properties",
 ]
 
-import builtins
 import io
 from _lzma import *
 
 
 _MODE_CLOSED   = 0
 _MODE_READ     = 1
 _MODE_READ_EOF = 2
 _MODE_WRITE    = 3
 
 _BUFFER_SIZE = 8192
 
 
 class LZMAFile(io.BufferedIOBase):
 
     """A file object providing transparent LZMA (de)compression.
 
     An LZMAFile can act as a wrapper for an existing file object, or
     refer directly to a named file on disk.
 
     Note that LZMAFile provides a *binary* file interface - data read
     is returned as bytes, and data to be written must be given as bytes.
     """
 
     def __init__(self, filename=None, mode="r", *,
-                 format=None, check=-1, preset=None, filters=None):
-        """Open an LZMA-compressed file in binary mode.
-
-        filename can be either an actual file name (given as a str or
-        bytes object), in which case the named file is opened, or it can
-        be an existing file object to read from or write to.
+                 fileobj=None, format=None, check=-1,
+                 preset=None, filters=None):
+        """Open an LZMA-compressed file.
+
+        If filename is given, open the named file. Otherwise, operate on
+        the file object given by fileobj. Exactly one of these two
+        parameters should be provided.
 
         mode can be "r" for reading (default), "w" for (over)writing, or
-        "a" for appending. These can equivalently be given as "rb", "wb",
-        and "ab" respectively.
+        "a" for appending.
 
         format specifies the container format to use for the file.
         If mode is "r", this defaults to FORMAT_AUTO. Otherwise, the
         default is FORMAT_XZ.
 
         check specifies the integrity check to use. This argument can
         only be used when opening a file for writing. For FORMAT_XZ,
         the default is CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not
         support integrity checks - for these formats, check must be
         omitted, or be CHECK_NONE.
@@ skipping 18 matching lines @@
         filters (if provided) should be a sequence of dicts. Each dict
         should have an entry for "id" indicating ID of the filter, plus
         additional entries for options to the filter.
         """
         self._fp = None
         self._closefp = False
         self._mode = _MODE_CLOSED
         self._pos = 0
         self._size = -1
 
-        if mode in ("r", "rb"):
+        if mode == "r":
             if check != -1:
                 raise ValueError("Cannot specify an integrity check "
                                  "when opening a file for reading")
             if preset is not None:
                 raise ValueError("Cannot specify a preset compression "
                                  "level when opening a file for reading")
             if format is None:
                 format = FORMAT_AUTO
             mode_code = _MODE_READ
             # Save the args to pass to the LZMADecompressor initializer.
             # If the file contains multiple compressed streams, each
             # stream will need a separate decompressor object.
             self._init_args = {"format":format, "filters":filters}
             self._decompressor = LZMADecompressor(**self._init_args)
             self._buffer = None
-        elif mode in ("w", "wb", "a", "ab"):
+        elif mode in ("w", "a"):
             if format is None:
                 format = FORMAT_XZ
             mode_code = _MODE_WRITE
             self._compressor = LZMACompressor(format=format, check=check,
                                               preset=preset, filters=filters)
         else:
             raise ValueError("Invalid mode: {!r}".format(mode))
 
-        if isinstance(filename, (str, bytes)):
-            if "b" not in mode:
-                mode += "b"
-            self._fp = builtins.open(filename, mode)
+        if filename is not None and fileobj is None:
+            mode += "b"
+            self._fp = open(filename, mode)
             self._closefp = True
             self._mode = mode_code
-        elif hasattr(filename, "read") or hasattr(filename, "write"):
-            self._fp = filename
+        elif fileobj is not None and filename is None:
+            self._fp = fileobj
             self._mode = mode_code
         else:
-            raise TypeError("filename must be a str or bytes object, or a file")
+            raise ValueError("Must give exactly one of filename and fileobj")
 
     def close(self):
         """Flush and close the file.
 
         May be called more than once without error. Once the file is
         closed, any other operation on it will raise a ValueError.
         """
         if self._mode == _MODE_CLOSED:
             return
         try:
@@ skipping 220 matching lines @@
             self._read_block(offset, return_data=False)
 
         return self._pos
 
     def tell(self):
         """Return the current file position."""
         self._check_not_closed()
         return self._pos
 
 
-def open(filename, mode="rb", *,
-         format=None, check=-1, preset=None, filters=None,
-         encoding=None, errors=None, newline=None):
-    """Open an LZMA-compressed file in binary or text mode.
-
-    filename can be either an actual file name (given as a str or bytes object),
-    in which case the named file is opened, or it can be an existing file object
-    to read from or write to.
-
-    The mode argument can be "r", "rb" (default), "w", "wb", "a", or "ab" for
-    binary mode, or "rt", "wt" or "at" for text mode.
-
-    The format, check, preset and filters arguments specify the compression
-    settings, as for LZMACompressor, LZMADecompressor and LZMAFile.
-
-    For binary mode, this function is equivalent to the LZMAFile constructor:
-    LZMAFile(filename, mode, ...). In this case, the encoding, errors and
-    newline arguments must not be provided.
-
-    For text mode, a LZMAFile object is created, and wrapped in an
-    io.TextIOWrapper instance with the specified encoding, error handling
-    behavior, and line ending(s).
-
-    """
-    if "t" in mode:
-        if "b" in mode:
-            raise ValueError("Invalid mode: %r" % (mode,))
-    else:
-        if encoding is not None:
-            raise ValueError("Argument 'encoding' not supported in binary mode")
-        if errors is not None:
-            raise ValueError("Argument 'errors' not supported in binary mode")
-        if newline is not None:
-            raise ValueError("Argument 'newline' not supported in binary mode")
-
-    lz_mode = mode.replace("t", "")
-    binary_file = LZMAFile(filename, lz_mode, format=format, check=check,
-                           preset=preset, filters=filters)
-
-    if "t" in mode:
-        return io.TextIOWrapper(binary_file, encoding, errors, newline)
-    else:
-        return binary_file
-
-
 def compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None):
     """Compress a block of data.
 
     Refer to LZMACompressor's docstring for a description of the
     optional arguments *format*, *check*, *preset* and *filters*.
 
     For incremental compression, use an LZMACompressor object instead.
     """
     comp = LZMACompressor(format, check, preset, filters)
     return comp.compress(data) + comp.flush()
@@ skipping 11 matching lines @@
     while True:
         decomp = LZMADecompressor(format, memlimit, filters)
         results.append(decomp.decompress(data))
         if not decomp.eof:
             raise LZMAError("Compressed data ended before the "
                             "end-of-stream marker was reached")
         if not decomp.unused_data:
             return b"".join(results)
         # There is unused data left over. Proceed to next stream.
         data = decomp.unused_data