cpython: f7ddec2e9e93 (original) (raw)

Mercurial > cpython

changeset 95517:f7ddec2e9e93 2.7

Issue #23865: close() methods in multiple modules now are idempotent and more robust at shutdown. If needs to release multiple resources, they are released even if errors are occured. [#23865]

Serhiy Storchaka storchaka@gmail.com
date	Fri, 10 Apr 2015 13:24:10 +0300
parents	50ed581fea04
children	0db36098b908
files	Lib/aifc.py Lib/binhex.py Lib/chunk.py Lib/distutils/text_file.py Lib/dumbdbm.py Lib/fileinput.py Lib/ftplib.py Lib/gzip.py Lib/httplib.py Lib/logging/__init__.py Lib/logging/handlers.py Lib/mailbox.py Lib/multiprocessing/connection.py Lib/multiprocessing/queues.py Lib/shelve.py Lib/smtplib.py Lib/tarfile.py Lib/telnetlib.py Lib/tempfile.py Lib/urllib.py Lib/wave.py Lib/xml/sax/expatreader.py Lib/xmlrpclib.py Misc/NEWS
diffstat	24 files changed, 263 insertions(+), 175 deletions(-)[+] [-] Lib/aifc.py 11 Lib/binhex.py 44 Lib/chunk.py 6 Lib/distutils/text_file.py 4 Lib/dumbdbm.py 6 Lib/fileinput.py 40 Lib/ftplib.py 15 Lib/gzip.py 26 Lib/httplib.py 21 Lib/logging/__init__.py 21 Lib/logging/handlers.py 23 Lib/mailbox.py 12 Lib/multiprocessing/connection.py 10 Lib/multiprocessing/queues.py 10 Lib/shelve.py 24 Lib/smtplib.py 16 Lib/tarfile.py 61 Lib/telnetlib.py 5 Lib/tempfile.py 8 Lib/urllib.py 15 Lib/wave.py 22 Lib/xml/sax/expatreader.py 14 Lib/xmlrpclib.py 20 Misc/NEWS 4

line wrap: on

line diff

--- a/Lib/aifc.py +++ b/Lib/aifc.py @@ -357,10 +357,13 @@ class Aifc_read: self._soundpos = 0 def close(self):

```
   if self._decomp:[](#l1.7)
```

       self._decomp.CloseDecompressor()[](#l1.8)

```
       self._decomp = None[](#l1.9)
```
```
   self._file.close()[](#l1.10)
```

```
   decomp = self._decomp[](#l1.11)
```
```
   try:[](#l1.12)
```
```
       if decomp:[](#l1.13)
```

           self._decomp = None[](#l1.14)

           decomp.CloseDecompressor()[](#l1.15)

```
   finally:[](#l1.16)
```
```
       self._file.close()[](#l1.17)
```

def tell(self): return self._soundpos

--- a/Lib/binhex.py +++ b/Lib/binhex.py @@ -32,7 +32,8 @@ class Error(Exception): pass

States (what have we written)

-[_DID_HEADER, _DID_DATA, _DID_RSRC] = range(3) +_DID_HEADER = 0 +_DID_DATA = 1

Various constants

REASONABLY_LARGE=32768 # Minimal amount we pass the rle-coder @@ -235,17 +236,22 @@ class BinHex: self._write(data) def close(self):

```
   if self.state < _DID_DATA:[](#l2.17)
```
```
       self.close_data()[](#l2.18)
```

   if self.state != _DID_DATA:[](#l2.19)

       raise Error, 'Close at the wrong time'[](#l2.20)

```
   if self.rlen != 0:[](#l2.21)
```
```
       raise Error, \[](#l2.22)
```

             "Incorrect resource-datasize, diff=%r" % (self.rlen,)[](#l2.23)

```
   self._writecrc()[](#l2.24)
```
```
   self.ofp.close()[](#l2.25)
```
```
   self.state = None[](#l2.26)
```
```
   del self.ofp[](#l2.27)
```

```
   if self.state is None:[](#l2.28)
```
```
       return[](#l2.29)
```
```
   try:[](#l2.30)
```

       if self.state < _DID_DATA:[](#l2.31)

```
           self.close_data()[](#l2.32)
```

       if self.state != _DID_DATA:[](#l2.33)

           raise Error, 'Close at the wrong time'[](#l2.34)

```
       if self.rlen != 0:[](#l2.35)
```
```
           raise Error, \[](#l2.36)
```

               "Incorrect resource-datasize, diff=%r" % (self.rlen,)[](#l2.37)

```
       self._writecrc()[](#l2.38)
```
```
   finally:[](#l2.39)
```
```
       self.state = None[](#l2.40)
```
```
       ofp = self.ofp[](#l2.41)
```
```
       del self.ofp[](#l2.42)
```
```
       ofp.close()[](#l2.43)
```

def binhex(inp, out): """(infilename, outfilename) - Create binhex-encoded copy of a file""" @@ -463,11 +469,15 @@ class HexBin: return self._read(n) def close(self):

```
   if self.rlen:[](#l2.51)
```

       dummy = self.read_rsrc(self.rlen)[](#l2.52)

```
   self._checkcrc()[](#l2.53)
```
```
   self.state = _DID_RSRC[](#l2.54)
```
```
   self.ifp.close()[](#l2.55)
```

```
   if self.state is None:[](#l2.56)
```
```
       return[](#l2.57)
```
```
   try:[](#l2.58)
```
```
       if self.rlen:[](#l2.59)
```

           dummy = self.read_rsrc(self.rlen)[](#l2.60)

```
       self._checkcrc()[](#l2.61)
```
```
   finally:[](#l2.62)
```
```
       self.state = None[](#l2.63)
```
```
       self.ifp.close()[](#l2.64)
```

def hexbin(inp, out): """(infilename, outfilename) - Decode binhexed file"""

--- a/Lib/chunk.py +++ b/Lib/chunk.py @@ -85,8 +85,10 @@ class Chunk: def close(self): if not self.closed:

```
       self.skip()[](#l3.7)
```
```
       self.closed = True[](#l3.8)
```

```
       try:[](#l3.9)
```
```
           self.skip()[](#l3.10)
```
```
       finally:[](#l3.11)
```
```
           self.closed = True[](#l3.12)
```

def isatty(self): if self.closed:

--- a/Lib/distutils/text_file.py +++ b/Lib/distutils/text_file.py @@ -124,11 +124,11 @@ class TextFile: def close (self): """Close the current file and forget everything we know about it (filename, current line number).""" -

```
   self.file.close ()[](#l4.8)
```

   file = self.file[](#l4.9)
   self.file = None[](#l4.10)
   self.filename = None[](#l4.11)
   self.current_line = None[](#l4.12)

```
   file.close()[](#l4.13)
```

def gen_error (self, msg, line=None):

--- a/Lib/dumbdbm.py +++ b/Lib/dumbdbm.py @@ -209,8 +209,10 @@ class _Database(UserDict.DictMixin): return len(self._index) def close(self):

```
   self._commit()[](#l5.7)
```

   self._index = self._datfile = self._dirfile = self._bakfile = None[](#l5.8)

```
   try:[](#l5.9)
```
```
       self._commit()[](#l5.10)
```
```
   finally:[](#l5.11)
```

       self._index = self._datfile = self._dirfile = self._bakfile = None[](#l5.12)

del = close

--- a/Lib/fileinput.py +++ b/Lib/fileinput.py @@ -233,8 +233,10 @@ class FileInput: self.close() def close(self):

```
   self.nextfile()[](#l6.7)
```
```
   self._files = ()[](#l6.8)
```

```
   try:[](#l6.9)
```
```
       self.nextfile()[](#l6.10)
```
```
   finally:[](#l6.11)
```
```
       self._files = ()[](#l6.12)
```

def iter(self): return self @@ -270,23 +272,25 @@ class FileInput: output = self._output self._output = 0

```
   if output:[](#l6.20)
```
```
       output.close()[](#l6.21)
```

```
   file = self._file[](#l6.23)
```
```
   self._file = 0[](#l6.24)
```

   if file and not self._isstdin:[](#l6.25)

```
       file.close()[](#l6.26)
```

```
   try:[](#l6.27)
```
```
       if output:[](#l6.28)
```
```
           output.close()[](#l6.29)
```
```
   finally:[](#l6.30)
```
```
       file = self._file[](#l6.31)
```
```
       self._file = 0[](#l6.32)
```
```
       try:[](#l6.33)
```

           if file and not self._isstdin:[](#l6.34)

```
               file.close()[](#l6.35)
```
```
       finally:[](#l6.36)
```

           backupfilename = self._backupfilename[](#l6.37)

           self._backupfilename = 0[](#l6.38)

           if backupfilename and not self._backup:[](#l6.39)

               try: os.unlink(backupfilename)[](#l6.40)

               except OSError: pass[](#l6.41)

   backupfilename = self._backupfilename[](#l6.43)

```
   self._backupfilename = 0[](#l6.44)
```

   if backupfilename and not self._backup:[](#l6.45)

       try: os.unlink(backupfilename)[](#l6.46)

```
       except OSError: pass[](#l6.47)
```

```
   self._isstdin = False[](#l6.49)
```
```
   self._buffer = [][](#l6.50)
```
```
   self._bufindex = 0[](#l6.51)
```

           self._isstdin = False[](#l6.52)

```
           self._buffer = [][](#l6.53)
```
```
           self._bufindex = 0[](#l6.54)
```

def readline(self): try:

--- a/Lib/ftplib.py +++ b/Lib/ftplib.py @@ -594,11 +594,16 @@ class FTP: def close(self): '''Close the connection without assuming anything about it.'''

```
   if self.file is not None:[](#l7.7)
```
```
       self.file.close()[](#l7.8)
```
```
   if self.sock is not None:[](#l7.9)
```
```
       self.sock.close()[](#l7.10)
```

   self.file = self.sock = None[](#l7.11)

```
   try:[](#l7.12)
```
```
       file = self.file[](#l7.13)
```
```
       self.file = None[](#l7.14)
```
```
       if file is not None:[](#l7.15)
```
```
           file.close()[](#l7.16)
```
```
   finally:[](#l7.17)
```
```
       sock = self.sock[](#l7.18)
```
```
       self.sock = None[](#l7.19)
```
```
       if sock is not None:[](#l7.20)
```
```
           sock.close()[](#l7.21)
```

try: import ssl

--- a/Lib/gzip.py +++ b/Lib/gzip.py @@ -369,19 +369,21 @@ class GzipFile(io.BufferedIOBase): return self.fileobj is None def close(self):

```
   if self.fileobj is None:[](#l8.7)
```

```
   fileobj = self.fileobj[](#l8.8)
```

   if fileobj is None:[](#l8.9)
       return[](#l8.10)

```
   if self.mode == WRITE:[](#l8.11)
```

       self.fileobj.write(self.compress.flush())[](#l8.12)

       write32u(self.fileobj, self.crc)[](#l8.13)

       # self.size may exceed 2GB, or even 4GB[](#l8.14)

       write32u(self.fileobj, self.size & 0xffffffffL)[](#l8.15)

```
       self.fileobj = None[](#l8.16)
```
```
   elif self.mode == READ:[](#l8.17)
```
```
       self.fileobj = None[](#l8.18)
```
```
   if self.myfileobj:[](#l8.19)
```
```
       self.myfileobj.close()[](#l8.20)
```
```
       self.myfileobj = None[](#l8.21)
```

```
   self.fileobj = None[](#l8.22)
```
```
   try:[](#l8.23)
```
```
       if self.mode == WRITE:[](#l8.24)
```

           fileobj.write(self.compress.flush())[](#l8.25)

           write32u(fileobj, self.crc)[](#l8.26)

           # self.size may exceed 2GB, or even 4GB[](#l8.27)

           write32u(fileobj, self.size & 0xffffffffL)[](#l8.28)

```
   finally:[](#l8.29)
```

       myfileobj = self.myfileobj[](#l8.30)

```
       if myfileobj:[](#l8.31)
```

           self.myfileobj = None[](#l8.32)

```
           myfileobj.close()[](#l8.33)
```

def flush(self,zlib_mode=zlib.Z_SYNC_FLUSH): self._check_closed()

--- a/Lib/httplib.py +++ b/Lib/httplib.py @@ -560,9 +560,10 @@ class HTTPResponse: return True def close(self):

```
   if self.fp:[](#l9.7)
```
```
       self.fp.close()[](#l9.8)
```

```
   fp = self.fp[](#l9.9)
```

   if fp:[](#l9.10)
       self.fp = None[](#l9.11)

```
       fp.close()[](#l9.12)
```

def isclosed(self): # NOTE: it is possible that we will not ever call self.close(). This @@ -835,13 +836,17 @@ class HTTPConnection: def close(self): """Close the connection to the HTTP server."""

```
   if self.sock:[](#l9.20)
```

       self.sock.close()   # close it manually... there may be other refs[](#l9.21)

```
       self.sock = None[](#l9.22)
```
```
   if self.__response:[](#l9.23)
```

       self.__response.close()[](#l9.24)

       self.__response = None[](#l9.25)
   self.__state = _CS_IDLE[](#l9.26)

```
   try:[](#l9.27)
```
```
       sock = self.sock[](#l9.28)
```
```
       if sock:[](#l9.29)
```
```
           self.sock = None[](#l9.30)
```

           sock.close()   # close it manually... there may be other refs[](#l9.31)

```
   finally:[](#l9.32)
```

       response = self.__response[](#l9.33)

```
       if response:[](#l9.34)
```

           self.__response = None[](#l9.35)

```
           response.close()[](#l9.36)
```

def send(self, data): """Send `data' to the server."""

--- a/Lib/logging/init.py +++ b/Lib/logging/init.py @@ -916,14 +916,19 @@ class FileHandler(StreamHandler): """ self.acquire() try:

```
       if self.stream:[](#l10.7)
```
```
           self.flush()[](#l10.8)
```

           if hasattr(self.stream, "close"):[](#l10.9)

               self.stream.close()[](#l10.10)

           self.stream = None[](#l10.11)

       # Issue #19523: call unconditionally to[](#l10.12)

       # prevent a handler leak when delay is set[](#l10.13)

       StreamHandler.close(self)[](#l10.14)

```
       try:[](#l10.15)
```
```
           if self.stream:[](#l10.16)
```
```
               try:[](#l10.17)
```

                   self.flush()[](#l10.18)

```
               finally:[](#l10.19)
```

                   stream = self.stream[](#l10.20)

                   self.stream = None[](#l10.21)

                   if hasattr(stream, "close"):[](#l10.22)

                       stream.close()[](#l10.23)

```
       finally:[](#l10.24)
```

           # Issue #19523: call unconditionally to[](#l10.25)

           # prevent a handler leak when delay is set[](#l10.26)

           StreamHandler.close(self)[](#l10.27)
   finally:[](#l10.28)
       self.release()[](#l10.29)

--- a/Lib/logging/handlers.py +++ b/Lib/logging/handlers.py @@ -588,9 +588,10 @@ class SocketHandler(logging.Handler): """ self.acquire() try:

```
       if self.sock:[](#l11.7)
```
```
           self.sock.close()[](#l11.8)
```

```
       sock = self.sock[](#l11.9)
```

       if sock:[](#l11.10)
           self.sock = None[](#l11.11)

           sock.close()[](#l11.12)
   finally:[](#l11.13)
       self.release()[](#l11.14)
   logging.Handler.close(self)[](#l11.15)

@@ -1160,8 +1161,10 @@ class BufferingHandler(logging.Handler): This version just flushes and chains to the parent class' close(). """

```
   self.flush()[](#l11.20)
```

   logging.Handler.close(self)[](#l11.21)

```
   try:[](#l11.22)
```
```
       self.flush()[](#l11.23)
```
```
   finally:[](#l11.24)
```

       logging.Handler.close(self)[](#l11.25)

class MemoryHandler(BufferingHandler): """ @@ -1213,10 +1216,12 @@ class MemoryHandler(BufferingHandler): """ Flush, set the target to None and lose the buffer. """

```
   self.flush()[](#l11.33)
```

   self.acquire()[](#l11.34)
   try:[](#l11.35)

```
       self.target = None[](#l11.36)
```

       BufferingHandler.close(self)[](#l11.37)

       self.flush()[](#l11.38)
   finally:[](#l11.39)

```
       self.release()[](#l11.40)
```

```
       self.acquire()[](#l11.41)
```
```
       try:[](#l11.42)
```

           self.target = None[](#l11.43)

           BufferingHandler.close(self)[](#l11.44)

```
       finally:[](#l11.45)
```
```
           self.release()[](#l11.46)
```

--- a/Lib/mailbox.py +++ b/Lib/mailbox.py @@ -719,10 +719,14 @@ class _singlefileMailbox(Mailbox): def close(self): """Flush and close the mailbox."""

```
   self.flush()[](#l12.7)
```
```
   if self._locked:[](#l12.8)
```
```
       self.unlock()[](#l12.9)
```

   self._file.close()  # Sync has been done by self.flush() above.[](#l12.10)

```
   try:[](#l12.11)
```
```
       self.flush()[](#l12.12)
```
```
   finally:[](#l12.13)
```
```
       try:[](#l12.14)
```
```
           if self._locked:[](#l12.15)
```
```
               self.unlock()[](#l12.16)
```
```
       finally:[](#l12.17)
```

           self._file.close()  # Sync has been done by self.flush() above.[](#l12.18)

def _lookup(self, key=None): """Return (start, stop) or raise KeyError."""

--- a/Lib/multiprocessing/connection.py +++ b/Lib/multiprocessing/connection.py @@ -285,9 +285,13 @@ class SocketListener(object): return conn def close(self):

```
   self._socket.close()[](#l13.7)
```

   if self._unlink is not None:[](#l13.8)

```
       self._unlink()[](#l13.9)
```

```
   try:[](#l13.10)
```
```
       self._socket.close()[](#l13.11)
```
```
   finally:[](#l13.12)
```
```
       unlink = self._unlink[](#l13.13)
```

       if unlink is not None:[](#l13.14)

           self._unlink = None[](#l13.15)

```
           unlink()[](#l13.16)
```

def SocketClient(address):

--- a/Lib/multiprocessing/queues.py +++ b/Lib/multiprocessing/queues.py @@ -156,9 +156,13 @@ class Queue(object): def close(self): self._closed = True

```
   self._reader.close()[](#l14.7)
```
```
   if self._close:[](#l14.8)
```
```
       self._close()[](#l14.9)
```

```
   try:[](#l14.10)
```
```
       self._reader.close()[](#l14.11)
```
```
   finally:[](#l14.12)
```
```
       close = self._close[](#l14.13)
```
```
       if close:[](#l14.14)
```

           self._close = None[](#l14.15)

```
           close()[](#l14.16)
```

def join_thread(self): debug('Queue.join_thread()')

--- a/Lib/shelve.py +++ b/Lib/shelve.py @@ -140,17 +140,21 @@ class Shelf(UserDict.DictMixin): pass def close(self):

```
   self.sync()[](#l15.7)
```

```
   if self.dict is None:[](#l15.8)
```

       return[](#l15.9)
   try:[](#l15.10)

```
       self.dict.close()[](#l15.11)
```
```
   except AttributeError:[](#l15.12)
```
```
       pass[](#l15.13)
```

   # Catch errors that may happen when close is called from __del__[](#l15.14)

   # because CPython is in interpreter shutdown.[](#l15.15)

```
   try:[](#l15.16)
```

       self.dict = _ClosedDict()[](#l15.17)

   except (NameError, TypeError):[](#l15.18)

```
       self.dict = None[](#l15.19)
```

```
       self.sync()[](#l15.20)
```
```
       try:[](#l15.21)
```
```
           self.dict.close()[](#l15.22)
```

       except AttributeError:[](#l15.23)

```
           pass[](#l15.24)
```
```
   finally:[](#l15.25)
```

       # Catch errors that may happen when close is called from __del__[](#l15.26)

       # because CPython is in interpreter shutdown.[](#l15.27)

```
       try:[](#l15.28)
```

           self.dict = _ClosedDict()[](#l15.29)

```
       except:[](#l15.30)
```
```
           self.dict = None[](#l15.31)
```

def del(self): if not hasattr(self, 'writeback'):

--- a/Lib/smtplib.py +++ b/Lib/smtplib.py @@ -750,12 +750,16 @@ class SMTP: def close(self): """Close the connection to the SMTP server."""

```
   if self.file:[](#l16.7)
```
```
       self.file.close()[](#l16.8)
```
```
   self.file = None[](#l16.9)
```
```
   if self.sock:[](#l16.10)
```
```
       self.sock.close()[](#l16.11)
```
```
   self.sock = None[](#l16.12)
```

```
   try:[](#l16.13)
```
```
       file = self.file[](#l16.14)
```
```
       self.file = None[](#l16.15)
```
```
       if file:[](#l16.16)
```
```
           file.close()[](#l16.17)
```
```
   finally:[](#l16.18)
```
```
       sock = self.sock[](#l16.19)
```
```
       self.sock = None[](#l16.20)
```
```
       if sock:[](#l16.21)
```
```
           sock.close()[](#l16.22)
```

def quit(self):

--- a/Lib/tarfile.py +++ b/Lib/tarfile.py @@ -492,26 +492,26 @@ class _Stream: if self.closed: return

   if self.mode == "w" and self.comptype != "tar":[](#l17.7)

       self.buf += self.cmp.flush()[](#l17.8)

```
   self.closed = True[](#l17.9)
```
```
   try:[](#l17.10)
```

       if self.mode == "w" and self.comptype != "tar":[](#l17.11)

           self.buf += self.cmp.flush()[](#l17.12)

   if self.mode == "w" and self.buf:[](#l17.14)

       self.fileobj.write(self.buf)[](#l17.15)

```
       self.buf = ""[](#l17.16)
```

       if self.comptype == "gz":[](#l17.17)

           # The native zlib crc is an unsigned 32-bit integer, but[](#l17.18)

           # the Python wrapper implicitly casts that to a signed C[](#l17.19)

           # long.  So, on a 32-bit box self.crc may "look negative",[](#l17.20)

           # while the same crc on a 64-bit box may "look positive".[](#l17.21)

           # To avoid irksome warnings from the `struct` module, force[](#l17.22)

           # it to look positive on all boxes.[](#l17.23)

           self.fileobj.write(struct.pack("<L", self.crc & 0xffffffffL))[](#l17.24)

           self.fileobj.write(struct.pack("<L", self.pos & 0xffffFFFFL))[](#l17.25)

```
   if not self._extfileobj:[](#l17.27)
```
```
       self.fileobj.close()[](#l17.28)
```

```
   self.closed = True[](#l17.30)
```

       if self.mode == "w" and self.buf:[](#l17.31)

           self.fileobj.write(self.buf)[](#l17.32)

```
           self.buf = ""[](#l17.33)
```

           if self.comptype == "gz":[](#l17.34)

               # The native zlib crc is an unsigned 32-bit integer, but[](#l17.35)

               # the Python wrapper implicitly casts that to a signed C[](#l17.36)

               # long.  So, on a 32-bit box self.crc may "look negative",[](#l17.37)

               # while the same crc on a 64-bit box may "look positive".[](#l17.38)

               # To avoid irksome warnings from the `struct` module, force[](#l17.39)

               # it to look positive on all boxes.[](#l17.40)

               self.fileobj.write(struct.pack("<L", self.crc & 0xffffffffL))[](#l17.41)

               self.fileobj.write(struct.pack("<L", self.pos & 0xffffFFFFL))[](#l17.42)

```
   finally:[](#l17.43)
```

       if not self._extfileobj:[](#l17.44)

           self.fileobj.close()[](#l17.45)

def _init_read_gz(self): """Initialize for reading a gzip compressed fileobj. @@ -1796,18 +1796,19 @@ class TarFile(object): if self.closed: return

```
   if self.mode in "aw":[](#l17.53)
```

       self.fileobj.write(NUL * (BLOCKSIZE * 2))[](#l17.54)

       self.offset += (BLOCKSIZE * 2)[](#l17.55)

       # fill up the end with zero-blocks[](#l17.56)

       # (like option -b20 for tar does)[](#l17.57)

       blocks, remainder = divmod(self.offset, RECORDSIZE)[](#l17.58)

```
       if remainder > 0:[](#l17.59)
```

           self.fileobj.write(NUL * (RECORDSIZE - remainder))[](#l17.60)

```
   if not self._extfileobj:[](#l17.62)
```

       self.fileobj.close()[](#l17.63)
   self.closed = True[](#l17.64)

```
   try:[](#l17.65)
```
```
       if self.mode in "aw":[](#l17.66)
```

           self.fileobj.write(NUL * (BLOCKSIZE * 2))[](#l17.67)

           self.offset += (BLOCKSIZE * 2)[](#l17.68)

           # fill up the end with zero-blocks[](#l17.69)

           # (like option -b20 for tar does)[](#l17.70)

           blocks, remainder = divmod(self.offset, RECORDSIZE)[](#l17.71)

```
           if remainder > 0:[](#l17.72)
```

               self.fileobj.write(NUL * (RECORDSIZE - remainder))[](#l17.73)

```
   finally:[](#l17.74)
```

       if not self._extfileobj:[](#l17.75)

           self.fileobj.close()[](#l17.76)

def getmember(self, name): """Return a TarInfo object for member name'. If name' can not be

--- a/Lib/telnetlib.py +++ b/Lib/telnetlib.py @@ -254,12 +254,13 @@ class Telnet: def close(self): """Close the connection."""

```
   if self.sock:[](#l18.7)
```
```
       self.sock.close()[](#l18.8)
```

   sock = self.sock[](#l18.9)
   self.sock = 0[](#l18.10)
   self.eof = 1[](#l18.11)
   self.iacseq = ''[](#l18.12)
   self.sb = 0[](#l18.13)

```
   if sock:[](#l18.14)
```
```
       sock.close()[](#l18.15)
```

def get_socket(self): """Return the socket object used internally."""

--- a/Lib/tempfile.py +++ b/Lib/tempfile.py @@ -413,9 +413,11 @@ class _TemporaryFileWrapper: def close(self): if not self.close_called: self.close_called = True

```
           self.file.close()[](#l19.7)
```
```
           if self.delete:[](#l19.8)
```

               self.unlink(self.name)[](#l19.9)

```
           try:[](#l19.10)
```

               self.file.close()[](#l19.11)

```
           finally:[](#l19.12)
```

               if self.delete:[](#l19.13)

                   self.unlink(self.name)[](#l19.14)

def del(self): self.close()

--- a/Lib/urllib.py +++ b/Lib/urllib.py @@ -994,11 +994,16 @@ class addclosehook(addbase): self.hookargs = hookargs def close(self):

```
   if self.closehook:[](#l20.7)
```

       self.closehook(*self.hookargs)[](#l20.8)

```
       self.closehook = None[](#l20.9)
```
```
       self.hookargs = None[](#l20.10)
```
```
   addbase.close(self)[](#l20.11)
```

```
   try:[](#l20.12)
```

       closehook = self.closehook[](#l20.13)

       hookargs = self.hookargs[](#l20.14)

```
       if closehook:[](#l20.15)
```

           self.closehook = None[](#l20.16)

           self.hookargs = None[](#l20.17)

           closehook(*hookargs)[](#l20.18)

```
   finally:[](#l20.19)
```
```
       addbase.close(self)[](#l20.20)
```

+ class addinfo(addbase): """class to add an info() method to an open file."""

--- a/Lib/wave.py +++ b/Lib/wave.py @@ -180,10 +180,11 @@ class Wave_read: self._soundpos = 0 def close(self):

   if self._i_opened_the_file:[](#l21.7)

       self._i_opened_the_file.close()[](#l21.8)

```
   self._file = None[](#l21.9)
```

   file = self._i_opened_the_file[](#l21.10)

   if file:[](#l21.11)
       self._i_opened_the_file = None[](#l21.12)

```
   self._file = None[](#l21.13)
```

```
       file.close()[](#l21.14)
```

def tell(self): return self._soundpos @@ -444,17 +445,18 @@ class Wave_write: self._patchheader() def close(self):

```
   if self._file:[](#l21.22)
```
```
       try:[](#l21.23)
```

```
   try:[](#l21.24)
```

       if self._file:[](#l21.25)
           self._ensure_header_written(0)[](#l21.26)
           if self._datalength != self._datawritten:[](#l21.27)
               self._patchheader()[](#l21.28)
           self._file.flush()[](#l21.29)

```
       finally:[](#l21.30)
```
```
           self._file = None[](#l21.31)
```

   if self._i_opened_the_file:[](#l21.32)

       self._i_opened_the_file.close()[](#l21.33)

       self._i_opened_the_file = None[](#l21.34)

```
   finally:[](#l21.35)
```
```
       self._file = None[](#l21.36)
```

       file = self._i_opened_the_file[](#l21.37)

```
       if file:[](#l21.38)
```

           self._i_opened_the_file = None[](#l21.39)

```
           file.close()[](#l21.40)
```

# # Internal methods.

--- a/Lib/xml/sax/expatreader.py +++ b/Lib/xml/sax/expatreader.py @@ -214,14 +214,16 @@ class ExpatParser(xmlreader.IncrementalP self._err_handler.fatalError(exc) def close(self):

```
   if self._entity_stack:[](#l22.7)
```

   if self._entity_stack or self._parser is None:[](#l22.8)
       # If we are completing an external entity, do nothing here[](#l22.9)
       return[](#l22.10)

   self.feed("", isFinal = 1)[](#l22.11)

   self._cont_handler.endDocument()[](#l22.12)

```
   self._parsing = 0[](#l22.13)
```

   # break cycle created by expat handlers pointing to our methods[](#l22.14)

```
   self._parser = None[](#l22.15)
```

```
   try:[](#l22.16)
```

       self.feed("", isFinal = 1)[](#l22.17)

       self._cont_handler.endDocument()[](#l22.18)

```
   finally:[](#l22.19)
```
```
       self._parsing = 0[](#l22.20)
```

       # break cycle created by expat handlers pointing to our methods[](#l22.21)

```
       self._parser = None[](#l22.22)
```

def _reset_cont_handler(self): self._parser.ProcessingInstructionHandler = [](#l22.25)

--- a/Lib/xmlrpclib.py +++ b/Lib/xmlrpclib.py @@ -558,8 +558,13 @@ else: self._parser.Parse(data, 0) def close(self):

       self._parser.Parse("", 1) # end of data[](#l23.7)

       del self._target, self._parser # get rid of circular references[](#l23.8)

```
       try:[](#l23.9)
```

           parser = self._parser[](#l23.10)

       except AttributeError:[](#l23.11)

```
           pass[](#l23.12)
```
```
       else:[](#l23.13)
```

           del self._target, self._parser # get rid of circular references[](#l23.14)

           parser.Parse("", 1) # end of data[](#l23.15)

class SlowParser: """Default XML parser (based on xmllib.XMLParser).""" @@ -1214,8 +1219,10 @@ class GzipDecodedResponse(gzip.GzipFile gzip.GzipFile.init(self, mode="rb", fileobj=self.stringio) def close(self):

```
   gzip.GzipFile.close(self)[](#l23.23)
```
```
   self.stringio.close()[](#l23.24)
```

```
   try:[](#l23.25)
```

       gzip.GzipFile.close(self)[](#l23.26)

```
   finally:[](#l23.27)
```
```
       self.stringio.close()[](#l23.28)
```

--------------------------------------------------------------------

@@ -1384,9 +1391,10 @@ class Transport: # Used in the event of socket errors. # def close(self):

```
   if self._connection[1]:[](#l23.36)
```

       self._connection[1].close()[](#l23.37)

   host, connection = self._connection[](#l23.38)

   if connection:[](#l23.39)
       self._connection = (None, None)[](#l23.40)

```
       connection.close()[](#l23.41)
```

## # Send request header.

--- a/Misc/NEWS +++ b/Misc/NEWS @@ -21,6 +21,10 @@ Core and Builtins Library ------- +- Issue #23865: close() methods in multiple modules now are idempotent and more

robust at shutdown. If needs to release multiple resources, they are released
even if errors are occured. +

Issue #23881: urllib.ftpwrapper constructor now closes the socket if the FTP connection failed.