gh-88661: Drop .taz, and teach the command line the same suffixes

.taz names a .tar.Z, and this module does not do compress(1), so mapping
it to .tar was wrong.  Only .gz and .tgz are handled now.

The suffix logic moved into a small helper that both the header writer
and main() use, so python -m gzip -d accepts what gunzip accepts and
writes the name gunzip would write.  It rejected spam.tgz and spam.GZ
before, which was the inconsistency Serhiy pointed out.

The existing command-line error test asserted the old message text; it
now asserts the new one and also covers .taz, which is refused.

Author: v0ropaev

Doc/whatsnew/3.16.rst

@@ -1046,13 +1046,13 @@ that may require changes to your code.
   (Contributed by An Long in :gh:`86768`.)
 
 * :mod:`gzip` and :mod:`tarfile` now derive the ``FNAME`` field of the gzip
-  header from the file name like :program:`gunzip` does for the ``.gz``,
-  ``.tgz`` and ``.taz`` suffixes: the suffix is matched ignoring case, and
-  ``.tgz`` and ``.taz`` are replaced with ``.tar`` instead of being left in
-  place.  For example, an archive created as :file:`spam.tgz` now records
-  ``spam.tar`` rather than ``spam.tgz``, and :file:`spam.GZ` records
-  ``spam`` rather than ``spam.GZ``.  Code comparing generated files byte for
-  byte may need to be updated.
+  header from the file name like :program:`gunzip` does: the suffix is matched
+  ignoring case, and ``.tgz`` is replaced with ``.tar`` instead of being left
+  in place.  For example, an archive created as :file:`spam.tgz` now records
+  ``spam.tar`` rather than ``spam.tgz``, and :file:`spam.GZ` records ``spam``
+  rather than ``spam.GZ``.  Code comparing generated files byte for byte may
+  need to be updated.  ``python -m gzip -d`` accepts the same names, where it
+  previously refused anything not ending in a lowercase ``.gz``.
   (Contributed by Dmitry Voropaev in :gh:`88661`.)
 
 

Lib/gzip.py

@@ -145,6 +145,25 @@ def writable(self):
         return True
 
 
+def _gunzip_name(name):
+    """The name :program:`gunzip` would decompress *name* to, or ``None``.
+
+    The suffix is matched ignoring case, and ``.tgz`` becomes ``.tar`` rather
+    than being stripped.  ``.taz`` is not handled: it means a ``.tar.Z``, and
+    this module does not do :program:`compress`.  Accepts and returns either
+    :class:`str` or :class:`bytes`.
+    """
+    if isinstance(name, bytes):
+        gz, tgz, tar = b'.gz', b'.tgz', b'.tar'
+    else:
+        gz, tgz, tar = '.gz', '.tgz', '.tar'
+    if name[-3:].lower() == gz:
+        return name[:-3]
+    if name[-4:].lower() == tgz:
+        return name[:-4] + tar
+    return None
+
+
 class GzipFile(_streams.BaseStream):
     """The GzipFile class simulates most of the methods of a file object with
     the exception of the truncate() method.
@@ -288,12 +307,9 @@ def _write_gzip_header(self, compresslevel):
             fname = os.path.basename(self.name)
             if not isinstance(fname, bytes):
                 fname = fname.encode('latin-1')
-            # Like gunzip, match the suffix ignoring case, and turn ".tgz"
-            # and ".taz" into ".tar" instead of just stripping them.
-            if fname[-3:].lower() == b'.gz':
-                fname = fname[:-3]
-            elif fname[-4:].lower() in (b'.tgz', b'.taz'):
-                fname = fname[:-4] + b'.tar'
+            stripped = _gunzip_name(fname)
+            if stripped is not None:
+                fname = stripped
         except UnicodeEncodeError:
             fname = b''
         flags = 0
@@ -733,10 +749,11 @@ def main():
                 f = GzipFile(filename="", mode="rb", fileobj=sys.stdin.buffer)
                 g = sys.stdout.buffer
             else:
-                if arg[-3:] != ".gz":
-                    sys.exit(f"filename doesn't end in .gz: {arg!r}")
+                out = _gunzip_name(arg)
+                if out is None:
+                    sys.exit(f"filename doesn't end in .gz or .tgz: {arg!r}")
                 f = open(arg, "rb")
-                g = builtins.open(arg[:-3], "wb")
+                g = builtins.open(out, "wb")
         else:
             if arg == "-":
                 f = sys.stdin.buffer

Lib/tarfile.py

@@ -456,11 +456,12 @@ def _init_write_gz(self, compresslevel, mtime):
             mtime = int(time.time())
         timestamp = struct.pack("<L", mtime)
         self.__write(b"\037\213\010\010" + timestamp + b"\002\377")
-        # Like gunzip, match the suffix ignoring case, and turn ".tgz"
-        # and ".taz" into ".tar" instead of just stripping them.
+        # Like gunzip, match the suffix ignoring case, and turn ".tgz" into
+        # ".tar" instead of just stripping it.  (gzip._gunzip_name does the
+        # same, but importing gzip here would pull it into the w|gz path.)
         if self.name[-3:].lower() == ".gz":
             self.name = self.name[:-3]
-        elif self.name[-4:].lower() in (".tgz", ".taz"):
+        elif self.name[-4:].lower() == ".tgz":
             self.name = self.name[:-4] + ".tar"
         # Honor "directory components removed" from RFC1952
         self.name = os.path.basename(self.name)

Lib/test/test_gzip.py

@@ -440,7 +440,7 @@ def test_metadata_ascii_name(self):
     def test_metadata_name_suffix(self):
         # gh-88661: the FNAME field holds the name that the file is expected
         # to have after decompression.  Like gunzip, the suffix is matched
-        # ignoring case, and ".tgz" and ".taz" are turned into ".tar".
+        # ignoring case, and ".tgz" is turned into ".tar".
         base = os_helper.TESTFN_ASCII
         # Only the suffix is matched ignoring case; the rest of the name
         # keeps the case it was given, the way make_ofname() does in gunzip.
@@ -452,13 +452,12 @@ def test_metadata_name_suffix(self):
                                    (base + '.tgz', base + '.tar'),
                                    (base + '.TGZ', base + '.tar'),
                                    (base + '.tGz', base + '.tar'),
-                                   (base + '.taz', base + '.tar'),
-                                   (base + '.TAZ', base + '.tar'),
                                    (base + '.tar', base + '.tar'),
+                                   # .taz means .tar.Z, which this module cannot read.
+                                   (base + '.taz', base + '.taz'),
                                    (base + '.tgz.gz', base + '.tgz'),
                                    (upper + '.GZ', upper),
-                                   (upper + '.TGZ', upper + '.tar'),
-                                   (upper + '.TAZ', upper + '.tar')):
+                                   (upper + '.TGZ', upper + '.tar')):
             with self.subTest(filename=filename):
                 try:
                     with gzip.GzipFile(filename, 'w') as f:
@@ -1187,10 +1186,35 @@ def test_decompress_infile_outfile(self):
         self.assertEqual(err, b'')
 
     def test_decompress_infile_outfile_error(self):
-        rc, out, err = assert_python_failure('-m', 'gzip', '-d', 'thisisatest.out')
-        self.assertEqual(b"filename doesn't end in .gz: 'thisisatest.out'", err.strip())
-        self.assertEqual(rc, 1)
-        self.assertEqual(out, b'')
+        # ".taz" is a ".tar.Z", which this module cannot read, so it is
+        # rejected along with names that carry no gzip suffix at all.
+        for name in ('thisisatest.out', 'thisisatest.taz'):
+            with self.subTest(name=name):
+                rc, out, err = assert_python_failure('-m', 'gzip', '-d', name)
+                self.assertEqual(
+                    f"filename doesn't end in .gz or .tgz: {name!r}".encode(),
+                    err.strip())
+                self.assertEqual(rc, 1)
+                self.assertEqual(out, b'')
+
+    @create_and_remove_directory(TEMPDIR)
+    def test_decompress_suffix_like_gunzip(self):
+        # gh-88661: the command line accepts the names gunzip accepts, and
+        # writes the name gunzip would write.
+        for name, expected in (('testgzip.tgz', 'testgzip.tar'),
+                               ('testgzip.TGZ', 'testgzip.tar'),
+                               ('testgzip.GZ', 'testgzip')):
+            with self.subTest(name=name):
+                path = os.path.join(TEMPDIR, name)
+                with gzip.open(path, mode='wb') as fp:
+                    fp.write(self.data)
+
+                rc, out, err = assert_python_ok('-m', 'gzip', '-d', path)
+                self.assertEqual(rc, 0)
+                self.assertEqual(err, b'')
+
+                with open(os.path.join(TEMPDIR, expected), 'rb') as gunziped:
+                    self.assertEqual(gunziped.read(), self.data)
 
     @requires_subprocess()
     @create_and_remove_directory(TEMPDIR)

Lib/test/test_tarfile.py

@@ -1970,7 +1970,7 @@ def test_missing_fileobj(self):
 class GzipFnameTestBase:
     # gh-88661: the FNAME field of the gzip header holds the name that the
     # archive is expected to have after decompression.  Like gunzip, the
-    # suffix is matched ignoring case, and ".tgz" and ".taz" become ".tar".
+    # suffix is matched ignoring case, and ".tgz" becomes ".tar".
 
     def gzip_header_fname(self, path):
         with open(path, "rb") as fobj:
@@ -1987,10 +1987,11 @@ def test_fname(self):
                                ("tmp.tgz", "tmp.tar"),
                                ("tmp.TGZ", "tmp.tar"),
                                ("tmp.tGz", "tmp.tar"),
-                               ("tmp.taz", "tmp.tar"),
-                               ("tmp.TAZ", "tmp.tar"),
+                               # .taz means .tar.Z, not gzip.
+                               ("tmp.taz", "tmp.taz"),
+                               ("tmp.TAZ", "tmp.TAZ"),
                                ("TMP.TGZ", "TMP.tar"),
-                               ("TMP.TAZ", "TMP.tar"),
+                               ("TMP.TAZ", "TMP.TAZ"),
                                ("tmp.tar", "tmp.tar")):
             with self.subTest(name=name):
                 path = os.path.join(TEMPDIR, name)

Misc/NEWS.d/next/Library/2026-09-24-18-23-43.gh-issue-88661.vOpGJy.rst

@@ -1,6 +1,6 @@
 When writing a gzip header, :mod:`gzip` and :mod:`tarfile` now derive the
-``FNAME`` field from the file name like :program:`gunzip` does for the
-``.gz``, ``.tgz`` and ``.taz`` suffixes: the suffix is matched ignoring
-case, and ``.tgz`` and ``.taz`` are replaced with ``.tar`` instead of being
+``FNAME`` field from the file name like :program:`gunzip` does: the suffix is
+matched ignoring case, and ``.tgz`` is replaced with ``.tar`` instead of being
 left in place.  Previously an archive created as :file:`spam.tgz` recorded
-``spam.tgz`` as the name to decompress to.
+``spam.tgz`` as the name to decompress to.  ``python -m gzip -d`` now accepts
+the same names, so :file:`spam.tgz` and :file:`spam.GZ` are no longer refused.