(joe) ...

Author: jbylund

locking/__init__.py

@@ -2,12 +2,17 @@
 xxx
 """
 
-class CouldNotLockException(Exception):
-    pass
 
 from .baselock import BaseLock
 from .dynamolock import DynamoLock
 from .filelock import FileLock
 from .redislock import RedisLock
 from .socketlock import SocketLock
 from .utils import get_caller
+
+__all__ = [
+    DynamoLock,
+    FileLock,
+    RedisLock,
+    SocketLock,
+]

locking/baselock.py

@@ -2,12 +2,15 @@
 import time
 import random
 
-from . import CouldNotLockException
 from .utils import get_caller
 
 TIMEOUT_MAX = int(sys.maxsize / 10**9)
 
 
+class CouldNotLockException(Exception):
+    pass
+
+
 class BaseLock(object):
 
     def __init__(self, lockname=None, block=True):

locking/custom_exceptions.py

@@ -0,0 +1,2 @@
+class CouldNotLockException(Exception):
+    pass

locking/tests/test_locks.py

@@ -2,60 +2,57 @@
 import time
 from _thread import start_new_thread
 
-import lock_tests
+RUNNING_ON_CI = True
+try:
+    import lock_tests
+except ImportError:
+    from test import lock_tests
+    RUNNING_ON_CI = False
 from .. import DynamoLock, FileLock, RedisLock, SocketLock
 
-RUNNING_ON_CI = True
-# try:
-# RUNNING_ON_CI = True
-# except ImportError:
-# RUNNING_ON_CI = False
-# from test import lock_tests, support
-
-
-if True:
-    class SocketLockTests(lock_tests.LockTests):
-        locktype = staticmethod(SocketLock)
-
-    class FileLockTests(lock_tests.LockTests):
-        locktype = staticmethod(FileLock)
-
-    if not RUNNING_ON_CI:
-        class DynamoLockTests(lock_tests.LockTests):
-            locktype = staticmethod(DynamoLock)
-
-            def tearDown(self):
-                for ithread in threading.enumerate():
-                    if hasattr(ithread, 'exit_flag'):
-                        ithread.exit_flag.set()
-                        ithread.join()
-
-            def test_reacquire(self):
-                """Copied in because the wait_threads_exit """
-                # Lock needs to be released before re-acquiring.
-                lock = self.locktype()
-                phase = []
-
-                def f():
-                    lock.acquire()
-                    phase.append(None)
-                    lock.acquire()
-                    phase.append(None)
-
-                with lock_tests.support.wait_threads_exit(timeout=5):
-                    start_new_thread(f, ())
-                    while len(phase) == 0:
-                        _wait()
+
+class SocketLockTests(lock_tests.LockTests):
+    locktype = staticmethod(SocketLock)
+
+class FileLockTests(lock_tests.LockTests):
+    locktype = staticmethod(FileLock)
+
+if not RUNNING_ON_CI:
+    class DynamoLockTests(lock_tests.LockTests):
+        locktype = staticmethod(DynamoLock)
+
+        def tearDown(self):
+            for ithread in threading.enumerate():
+                if hasattr(ithread, 'exit_flag'):
+                    ithread.exit_flag.set()
+                    ithread.join()
+
+        def test_reacquire(self):
+            """Copied in because the wait_threads_exit """
+            # Lock needs to be released before re-acquiring.
+            lock = self.locktype()
+            phase = []
+
+            def f():
+                lock.acquire()
+                phase.append(None)
+                lock.acquire()
+                phase.append(None)
+
+            with lock_tests.support.wait_threads_exit(timeout=5):
+                start_new_thread(f, ())
+                while len(phase) == 0:
                     _wait()
-                    self.assertEqual(len(phase), 1)
-                    lock.release()
-                    while len(phase) == 1:
-                        _wait()
-                    self.assertEqual(len(phase), 2)
-                    lock.release()
-
-            def test_thread_leak(self):
-                pass
+                _wait()
+                self.assertEqual(len(phase), 1)
+                lock.release()
+                while len(phase) == 1:
+                    _wait()
+                self.assertEqual(len(phase), 2)
+                lock.release()
+
+        def test_thread_leak(self):
+            pass
 
 
 def _wait():