Use context managers where reasonable

Author: Cito

webware/Application.py

@@ -220,6 +220,7 @@ def __init__(self, path=None, settings=None, development=None):
         if filename:
             if '/' not in filename:
                 filename = os.path.join(self._logDir, filename)
+            # pylint: disable=consider-using-with
             sys.stderr = sys.stdout = open(filename, 'a', buffering=1)
 
         self.initErrorPage()
@@ -609,31 +610,29 @@ def writeActivityLog(self, trans):
         if '/' not in filename:
             filename = os.path.join(self._logDir, filename)
         filename = self.serverSidePath(filename)
-        if os.path.exists(filename):
-            f = open(filename, 'a')
-        else:
-            f = open(filename, 'w')
-            f.write(','.join(self.setting('ActivityLogColumns')) + '\n')
-        values = []
-        objects = dict(
-            application=self, transaction=trans,
-            request=trans.request(), response=trans.response(),
-            servlet=trans.servlet(),
-            # don't cause creation of session here:
-            session=trans._session)
-        for column in self.setting('ActivityLogColumns'):
-            try:
-                value = valueForName(objects, column)
-            except Exception:
-                value = '(unknown)'
-            if isinstance(value, float):
-                # probably need more flexibility in the future
-                value = f'{value:02f}'
-            else:
-                value = str(value)
-            values.append(value)
-        f.write(','.join(values) + '\n')
-        f.close()
+        mode = 'a' if os.path.exists(filename) else 'w'
+        with open(filename, mode) as f:
+            if mode == 'w':
+                f.write(','.join(self.setting('ActivityLogColumns')) + '\n')
+            values = []
+            objects = dict(
+                application=self, transaction=trans,
+                request=trans.request(), response=trans.response(),
+                servlet=trans.servlet(),
+                # don't cause creation of session here:
+                session=trans._session)
+            for column in self.setting('ActivityLogColumns'):
+                try:
+                    value = valueForName(objects, column)
+                except Exception:
+                    value = '(unknown)'
+                if isinstance(value, float):
+                    # probably need more flexibility in the future
+                    value = f'{value:02f}'
+                else:
+                    value = str(value)
+                values.append(value)
+            f.write(','.join(values) + '\n')
 
     def startTime(self):
         """Return the time the application was started.

webware/MiscUtils/ParamFactory.py

@@ -16,13 +16,12 @@ def __init__(self, klass, **extraMethods):
             setattr(self, name, func)
 
     def __call__(self, *args):
-        self.lock.acquire()
-        if args in self.cache:
-            self.lock.release()
-            return self.cache[args]
-        value = self.klass(*args)
-        self.cache[args] = value
-        self.lock.release()
+        with self.lock:
+            if args in self.cache:
+                value = self.cache[args]
+            else:
+                value = self.klass(*args)
+                self.cache[args] = value
         return value
 
     def allInstances(self):

webware/MiscUtils/PickleCache.py

@@ -107,6 +107,7 @@ def read(self, filename,
                 try:
                     if v:
                         print(f'About to open for read {picklePath!r}.')
+                    # pylint: disable=consider-using-with
                     file = open(picklePath, 'rb')
                 except IOError as e:
                     if v:
@@ -209,7 +210,8 @@ def write(self, data, filename,
             pprint(d)
         try:
             if v:
-                print('About to open for write %r.' % picklePath)
+                print(f'About to open for write {picklePath!r}.')
+            # pylint: disable=consider-using-with
             pickleFile = open(picklePath, 'wb')
         except IOError as e:
             if v:
@@ -225,6 +227,7 @@ def write(self, data, filename,
                         print('Timestamps are identical, sleeping'
                               f' {self._writeSleepInterval:%0.2f} seconds.')
                     sleep(self._writeSleepInterval)
+                    # pylint: disable=consider-using-with
                     pickleFile = open(picklePath, 'wb')
                 else:
                     break

webware/ServletFactory.py

@@ -305,14 +305,13 @@ def flushCache(self):
         Servlets that are currently in the wild may find their way back
         into the cache (this may be a problem).
         """
-        self._importLock.acquire()
-        self._classCache = {}
-        # We can't just delete all the lists, because returning
-        # servlets expect it to exist.
-        for key in self._servletPool:
-            self._servletPool[key] = []
-        self._threadsafeServletCache = {}
-        self._importLock.release()
+        with self._importLock:
+            self._classCache = {}
+            # We can't just delete all the lists, because returning
+            # servlets expect it to exist.
+            for key in self._servletPool:
+                self._servletPool[key] = []
+            self._threadsafeServletCache = {}
 
     # endregion Servlet Pool
 

webware/SessionFileStore.py

@@ -46,6 +46,7 @@ def __getitem__(self, key):
         filename = self.filenameForKey(key)
         with self._lock:
             try:
+                # pylint: disable=consider-using-with
                 sessionFile = open(filename, 'rb')
             except IOError as e:
                 raise KeyError(key) from e  # session file not found
@@ -73,6 +74,7 @@ def __setitem__(self, key, value):
                 if dirty:
                     value.setDirty(False)
                 try:
+                    # pylint: disable=consider-using-with
                     sessionFile = open(filename, 'wb')
                     try:
                         try:

webware/Tests/TestEndToEnd/TestExamples.py

@@ -20,14 +20,15 @@ def setUp(self):
     @staticmethod
     def removeDemoDatabase():
         # pylint: disable=unused-variable
-        for i in range(20):
+        for i in range(40):
             if not os.path.exists('demo.db'):
                 break
             try:
                 os.remove('demo.db')
             except OSError:
                 sleep(.5)
             else:
+                sleep(.5)
                 break
 
     def testStartPage(self):

webware/Tests/TestEndToEnd/TestServer.py

@@ -168,6 +168,7 @@ def tearDownClass(cls):
             chdir(cls.currentDir)
 
     def getPage(self, path=''):
+        # pylint: disable=consider-using-with
         return urlopen(f'http://localhost:8080/{path}')
 
     def compareOutput(self, gotLines, expectedLines):

webware/UnknownFileTypeServlet.py

@@ -188,64 +188,64 @@ def serveContent(self, trans):
 
         filename = self.filename(trans)
         try:
+            # pylint: disable=consider-using-with
             f = open(filename, 'rb')
         except IOError as e:
             raise HTTPExceptions.HTTPNotFound from e
-
-        stat = os.fstat(f.fileno())
-        fileSize, mtime = stat[6], stat[8]
-
-        if debug:
-            print('>> UnknownFileType.serveContent()')
-            print('>> filename =', filename)
-            print('>> size=', fileSize)
-        fileDict = fileCache.get(filename)
-        if fileDict is not None and mtime != fileDict['mtime']:
-            # Cache is out of date; clear it.
-            if debug:
-                print('>> changed, clearing cache')
-            del fileCache[filename]
-            fileDict = None
-        if fileDict is None:
+        try:
+            stat = os.fstat(f.fileno())
+            fileSize, mtime = stat[6], stat[8]
             if debug:
-                print('>> not found in cache')
-            mimeType, mimeEncoding = guess_type(filename, False)
-            if mimeType is None:
-                mimeType, mimeEncoding = 'application/octet-stream', None
-        else:
-            mimeType = fileDict['mimeType']
-            mimeEncoding = fileDict['mimeEncoding']
-        response.setHeader('Content-Type', mimeType)
-        response.setHeader('Content-Length', str(fileSize))
-        if mimeEncoding:
-            response.setHeader('Content-Encoding', mimeEncoding)
-        if trans.request().method() == 'HEAD':
+                print('>> UnknownFileType.serveContent()')
+                print('>> filename =', filename)
+                print('>> size=', fileSize)
+            fileDict = fileCache.get(filename)
+            if fileDict is not None and mtime != fileDict['mtime']:
+                # Cache is out of date; clear it.
+                if debug:
+                    print('>> changed, clearing cache')
+                del fileCache[filename]
+                fileDict = None
+            if fileDict is None:
+                if debug:
+                    print('>> not found in cache')
+                mimeType, mimeEncoding = guess_type(filename, False)
+                if mimeType is None:
+                    mimeType, mimeEncoding = 'application/octet-stream', None
+            else:
+                mimeType = fileDict['mimeType']
+                mimeEncoding = fileDict['mimeEncoding']
+            response.setHeader('Content-Type', mimeType)
+            response.setHeader('Content-Length', str(fileSize))
+            if mimeEncoding:
+                response.setHeader('Content-Encoding', mimeEncoding)
+            if trans.request().method() == 'HEAD':
+                return
+            if (fileDict is None and self.setting('ReuseServlets')
+                    and self.shouldCacheContent()
+                    and fileSize < maxCacheContentSize):
+                if debug:
+                    print('>> caching')
+                fileDict = dict(
+                    content=f.read(),
+                    mimeType=mimeType, mimeEncoding=mimeEncoding,
+                    mtime=mtime, size=fileSize, filename=filename)
+                fileCache[filename] = fileDict
+            if fileDict is not None:
+                if debug:
+                    print('>> sending content from cache')
+                response.write(fileDict['content'])
+            else:  # too big or not supposed to cache
+                if debug:
+                    print('>> sending directly')
+                numBytesSent = 0
+                while numBytesSent < fileSize:
+                    data = f.read(min(fileSize-numBytesSent, readBufferSize))
+                    if data == '':
+                        break  # unlikely, but safety first
+                    response.write(data)
+                    numBytesSent += len(data)
+        finally:
             f.close()
-            return
-        if (fileDict is None and self.setting('ReuseServlets')
-                and self.shouldCacheContent()
-                and fileSize < maxCacheContentSize):
-            if debug:
-                print('>> caching')
-            fileDict = dict(
-                content=f.read(),
-                mimeType=mimeType, mimeEncoding=mimeEncoding,
-                mtime=mtime, size=fileSize, filename=filename)
-            fileCache[filename] = fileDict
-        if fileDict is not None:
-            if debug:
-                print('>> sending content from cache')
-            response.write(fileDict['content'])
-        else:  # too big or not supposed to cache
-            if debug:
-                print('>> sending directly')
-            numBytesSent = 0
-            while numBytesSent < fileSize:
-                data = f.read(min(fileSize-numBytesSent, readBufferSize))
-                if data == '':
-                    break  # unlikely, but safety first
-                response.write(data)
-                numBytesSent += len(data)
-        f.close()
 
     # endregion Init et al