How about just this?

$ gunzip *.txt.gz

gunzip will create a gunzipped file without the .gz suffix and remove the original file by default (see below for details). *.txt.gz will be expanded by your shell to all the files matching.

This last bit can get you into trouble if it expands to a very long list of files. In that case, try using find and -exec to do the job for you.

From the man page gzip(1):

gunzip takes a list of files on its command line and  replaces  each  file
whose  name  ends  with  .gz, -gz, .z, -z, or _z (ignoring case) and which
begins with the correct magic number with an uncompressed file without the
original  extension.

Note about 'original name'

gzip can store and restore the filename used at compression time. Even if you rename the compressed file, you can be surprised to find out it restores to the original name again.

From the gzip manpage:

By default, gzip keeps the original file name and timestamp in the compressed file. These are used when decompressing the file with the -N option. This is useful when the compressed file name was truncated or when the time stamp was not preserved after a file transfer.

And these file names stored in metadata can also be viewed with file:

$ echo "foo" > myfile_orig
$ gzip myfile_orig 
$ mv myfile_orig.gz myfile_new.gz 
$ file myfile_new.gz 
myfile_new.gz: gzip compressed data, was "myfile_orig", last modified: Mon Aug  5 08:46:39 2019, from Unix
$ gunzip myfile_new.gz        # gunzip without -N
$ ls myfile_*
myfile_new

$ rm myfile_*
$ echo "foo" > myfile_orig
$ gzip myfile_orig
$ mv myfile_orig.gz myfile_new.gz 
# gunzip with -N
$ gunzip -N myfile_new.gz     # gunzip with -N
$ ls myfile_*
myfile_orig

gunzip has -r option. From man gunzip :

   -r --recursive
          Travel  the directory structure recursively. If any of the 
file names specified on the command line are directories, gzip 
will descend into the directory and compress all the files it finds
there (or decompress them in  the  case  of gunzip ).

So, if you want to gunzip all compressed files (gunzip can currently decompress files created by gzip, zip, compress, compress -H or pack) inside the directory /foo/bar and all its subdirectories :

gunzip -r /foo/bar

This will handle file names with spaces too.

This might be what you're looking for:

for f in *.gz; do gunzip -c "$f" > /mnt/s3/data_transfer/"${f%.gz}"; done

You may remove the .gz files by rm *.gz after that, if you want. Or, alternatively

cp *.gz /mnt/s3/data_transfer/ && cd /mnt/s3/data_transfer && gunzip *.gz

Note that the latter command will gunzip all .gz files in the directory /mnt/s3/data_transfer, including the ones that exist, if any, before the cp command is executed. If you want to remove the original .gz files, replace cp with mv.

I'd prefer gzip -r ./ which does the same thing but is shorter.

Gzip compresses files, not directories. If you want to gzip a directory, you must first create a tarball. You can create a tarball and compress it in one step.

tar cvzf tarball.tar.gz directory/

(create, verbose, gZip, to this file)

to reverse the process

tar xvzf tarball.tar.gz

(eXtract)

tar -zcvf compressFileName.tar.gz folderToCompress

everything in folderToCompress will go to compressFileName

Edit: After review and comments I realized that people may get confused with compressFileName without an extension. If you want you can use .tar.gz extension(as suggested) with the compressFileName

I think you have misplaced the path.exists call. It should be:

source_dir = "/Users/path"
dest_dir = "/Users/path/Documents/path"


for src_name in glob.glob(os.path.join(source_dir, '*.gz')):

    base = os.path.basename(src_name)
    dest_name = os.path.join(dest_dir, base[:-3])

    if not os.path.exists(dest_name):
        with gzip.open(src_name, 'rb') as infile, open(dest_name, 'wb') as outfile:
            try:
                for line in infile:
                    print("outfile: %s" % outfile)
                    outfile.write(line)
                    print("converted: %s" % dest_name)

            except EOFError:
                print("End of file error occurred.")

            except Exception:
                print("Some error occurred.")

Also as @MadPhysicist emphasized: "doing the check after open(..., 'wb') (as you did in your original code), will always say that the file exists because that is what open(..., 'w') does"

On top of that even if you made some other check for the necessity of gunzipping, doing it where you've put it will do the check on every line, which is completely redundant as the result will be the same for all lines (exists/not-exists).

gzip will always compress each file into a single .gz file when given a list of files on its command line.

For example

$ gzip -r log.2011

to recursively walk the log.2011 directory and compress all files it finds, or

$ gzip log.2011/*

to compress only the files in the log.2011 directory without descending into subdirectories.

This should do it:

gunzip *.gz