polish

Author: chillaq

splitio/client/factory.py

@@ -135,8 +135,7 @@ def _start_status_updater(self):
             self._status = Status.NOT_INITIALIZED
             # add a listener that updates the status to READY once the flag is set.
             ready_updater = threading.Thread(target=self._update_status_when_ready,
-                                             name='SDKReadyFlagUpdater')
-            ready_updater.daemon = True
+                                             name='SDKReadyFlagUpdater', daemon=True)
             ready_updater.start()
         else:
             self._status = Status.READY
@@ -225,8 +224,7 @@ def _wait_for_tasks_to_stop():
                         self._sync_manager.stop(True)
                         destroyed_event.set()
 
-                    wait_thread = threading.Thread(target=_wait_for_tasks_to_stop)
-                    wait_thread.daemon = True
+                    wait_thread = threading.Thread(target=_wait_for_tasks_to_stop, daemon=True)
                     wait_thread.start()
                 else:
                     self._sync_manager.stop(False)
@@ -272,8 +270,8 @@ def resume(self):
         initialization_thread = threading.Thread(
             target=self._sync_manager.start,
             name="SDKInitializer",
+            daemon=True
         )
-        initialization_thread.daemon = True
         initialization_thread.start()
         self._preforked_initialization = False  # reset for status updater
         self._start_status_updater()
@@ -385,8 +383,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         return SplitFactory(api_key, storages, cfg['labelsEnabled'],
                             recorder, manager, preforked_initialization=preforked_initialization)
 
-    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer")
-    initialization_thread.daemon = True
+    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
     return SplitFactory(api_key, storages, cfg['labelsEnabled'],
@@ -440,8 +437,7 @@ def _build_redis_factory(api_key, cfg):
     )
 
     manager = RedisManager(synchronizer)
-    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer")
-    initialization_thread.daemon = True
+    initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
     return SplitFactory(

splitio/push/segmentworker.py

@@ -54,8 +54,7 @@ def start(self):
         self._running = True
 
         _LOGGER.debug('Starting Segment Worker')
-        self._worker = threading.Thread(target=self._run, name='PushSegmentWorker')
-        self._worker.daemon = True
+        self._worker = threading.Thread(target=self._run, name='PushSegmentWorker', daemon=True)
         self._worker.start()
 
     def stop(self):

splitio/push/splitsse.py

@@ -134,8 +134,7 @@ def connect(url):
                 self._on_disconnected()
 
         url = self._build_url(token)
-        task = threading.Thread(target=connect, name='SSEConnection', args=(url,))
-        task.daemon = True
+        task = threading.Thread(target=connect, name='SSEConnection', args=(url,), daemon=True)
         task.start()
         event_group.wait()
         return self._status == SplitSSEClient._Status.CONNECTED

splitio/push/splitworker.py

@@ -53,8 +53,7 @@ def start(self):
         self._running = True
 
         _LOGGER.debug('Starting Split Worker')
-        self._worker = threading.Thread(target=self._run, name='PushSplitWorker')
-        self._worker.daemon = True
+        self._worker = threading.Thread(target=self._run, name='PushSplitWorker', daemon=True)
         self._worker.start()
 
     def stop(self):

splitio/sync/manager.py

@@ -51,8 +51,7 @@ def __init__(self, ready_flag, synchronizer, auth_api, streaming_enabled, sdk_me
             self._queue = Queue()
             self._push = PushManager(auth_api, synchronizer, self._queue, sdk_metadata, sse_url, client_key)
             self._push_status_handler = Thread(target=self._streaming_feedback_handler,
-                                               name='PushStatusHandler')
-            self._push_status_handler.daemon = True
+                                               name='PushStatusHandler', daemon=True)
 
     def recreate(self):
         """Recreate poolers for forked processes."""

splitio/tasks/util/asynctask.py

@@ -128,8 +128,7 @@ def start(self):
 
         # Start execution
         self._thread = threading.Thread(target=self._execution_wrapper,
-                                        name='AsyncTask::' + getattr(self._main, '__name__', 'N/S'))
-        self._thread.daemon = True
+                                        name='AsyncTask::' + getattr(self._main, '__name__', 'N/S'), daemon=True)
         try:
             self._thread.start()
 

splitio/tasks/util/workerpool.py

@@ -116,8 +116,7 @@ def wait_for_completion(self):
 
     def stop(self, event=None):
         """Stop all worker nodes."""
-        async_stop = Thread(target=self._wait_workers_shutdown, args=(event,))
-        async_stop.daemon = True
+        async_stop = Thread(target=self._wait_workers_shutdown, args=(event,), daemon=True)
         async_stop.start()
 
     def _wait_workers_shutdown(self, event):

tests/helpers/mockserver.py

@@ -23,8 +23,7 @@ def __init__(self, req_queue=None):
         self._queue = queue.Queue()
         self._server = HTTPServer(('localhost', 0),
                                   lambda *xs: SSEHandler(self._queue, *xs, req_queue=req_queue))
-        self._server_thread = threading.Thread(target=self._blocking_run)
-        self._server_thread.daemon = True
+        self._server_thread = threading.Thread(target=self._blocking_run, daemon=True)
         self._done_event = threading.Event()
 
     def _blocking_run(self):
@@ -116,8 +115,7 @@ def __init__(self, split_changes=None, segment_changes=None, req_queue=None,
                                   lambda *xs: SDKHandler(split_changes, segment_changes, *xs,
                                                          req_queue=req_queue,
                                                          auth_response=auth_response))
-        self._server_thread = threading.Thread(target=self._blocking_run, name="SplitMockServer")
-        self._server_thread.daemon = True
+        self._server_thread = threading.Thread(target=self._blocking_run, name="SplitMockServer", daemon=True)
         self._done_event = threading.Event()
 
     def _blocking_run(self):

tests/push/test_manager.py

@@ -38,8 +38,7 @@ def test_connection_success(self, mocker):
 
         def new_start(*args, **kwargs):  # pylint: disable=unused-argument
             """splitsse.start mock."""
-            thread = Thread(target=manager._handle_connection_ready)
-            thread.daemon = True
+            thread = Thread(target=manager._handle_connection_ready, daemon=True)
             thread.start()
             return True
 
@@ -71,8 +70,7 @@ def test_connection_failure(self, mocker):
 
         def new_start(*args, **kwargs):  # pylint: disable=unused-argument
             """splitsse.start mock."""
-            thread = Thread(target=manager._handle_connection_end)
-            thread.daemon = True
+            thread = Thread(target=manager._handle_connection_end, daemon=True)
             thread.start()
             return False
 

tests/push/test_sse.py

@@ -25,8 +25,7 @@ def callback(event):
         def runner():
             """SSE client runner thread."""
             assert client.start('http://127.0.0.1:' + str(server.port()))
-        client_task = threading.Thread(target=runner)
-        client_task.daemon = True
+        client_task = threading.Thread(target=runner, daemon=True)
         client_task.setName('client')
         client_task.start()
         with pytest.raises(RuntimeError):
@@ -66,8 +65,7 @@ def callback(event):
         def runner():
             """SSE client runner thread."""
             assert client.start('http://127.0.0.1:' + str(server.port()))
-        client_task = threading.Thread(target=runner)
-        client_task.daemon = True
+        client_task = threading.Thread(target=runner, daemon=True)
         client_task.setName('client')
         client_task.start()
 
@@ -104,8 +102,7 @@ def callback(event):
         def runner():
             """SSE client runner thread."""
             assert client.start('http://127.0.0.1:' + str(server.port()))
-        client_task = threading.Thread(target=runner)
-        client_task.daemon = True
+        client_task = threading.Thread(target=runner, daemon=True)
         client_task.setName('client')
         client_task.start()