diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 5989973c..385a2a30 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
 
     steps:
     - uses: actions/checkout@v2
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index ec5ba411..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-language: python
-python:
-  - "2.7"
-  - "3.5"
-  - "3.6"
-  - "3.7"
-  - "3.8"
-install:
-  - pip install .
-  - pip install flake8 pylint coveralls
-  - python --version 2>&1 | grep -q "Python 2" && pip install mock || true
-  - if python --version 2>&1 | grep -q "Python 3.7" || python --version 2>&1 | grep -q "Python 3.8"; then pip install aiofiles; fi
-script:
-  - if python --version 2>&1 | grep -q "Python 2" || python --version 2>&1 | grep -q "Python 3.5" || python --version 2>&1 | grep -q "Python 3.6"; then flake8 androidtv/ --exclude="androidtv/setup_async.py,androidtv/basetv/basetv_async.py,androidtv/androidtv/androidtv_async.py,androidtv/firetv/firetv_async.py,androidtv/adb_manager/adb_manager_async.py" && pylint --ignore="setup_async.py,basetv_async.py,androidtv_async.py,firetv_async.py,adb_manager_async.py" androidtv/; fi
-  - if python --version 2>&1 | grep -q "Python 3.7" || python --version 2>&1 | grep -q "Python 3.8"; then flake8 androidtv/ && pylint androidtv/; fi
-  - if python --version 2>&1 | grep -q "Python 2" || python --version 2>&1 | grep -q "Python 3.5" || python --version 2>&1 | grep -q "Python 3.6" ; then for synctest in $(cd tests && ls test*.py | grep -v async); do python -m unittest discover -s tests/ -t . -p "$synctest" || exit 1; done; fi
-  - if python --version 2>&1 | grep -q "Python 3.7" || python --version 2>&1 | grep -q "Python 3.8"; then coverage run --source androidtv -m unittest discover -s tests/ -t . && coverage report -m; fi
-after_success:
-  - if python --version 2>&1 | grep -q "Python 3.7" || python --version 2>&1 | grep -q "Python 3.8"; then coveralls; fi
diff --git a/Makefile b/Makefile
index 9c347328..94bfce76 100644
--- a/Makefile
+++ b/Makefile
@@ -113,18 +113,18 @@ pre-commit: .git/hooks/pre-commit  ## Create the pre-commit hook
 # Linting and code analysis
 .PHONY: black
 black: venv  ## Format the code using black
-	$(BLACK) --safe --line-length 120 --target-version py35 $(PACKAGE_DIR)
-	$(BLACK) --safe --line-length 120 --target-version py35 $(TEST_DIR)
+	$(BLACK) --safe --line-length 120 --target-version py39 $(PACKAGE_DIR)
+	$(BLACK) --safe --line-length 120 --target-version py39 $(TEST_DIR)
 ifneq ("$(wildcard setup.py)", "")
-	$(BLACK) --safe --line-length 120 --target-version py35 setup.py
+	$(BLACK) --safe --line-length 120 --target-version py39 setup.py
 endif
 
 .PHONY: lint-black
 lint-black: venv  ## Check that the code is formatted using black
-	$(BLACK) --check --line-length 120 --safe --target-version py35 $(PACKAGE_DIR)
-	$(BLACK) --check --line-length 120 --safe --target-version py35 $(TEST_DIR)
+	$(BLACK) --check --line-length 120 --safe --target-version py39 $(PACKAGE_DIR)
+	$(BLACK) --check --line-length 120 --safe --target-version py39 $(TEST_DIR)
 ifneq ("$(wildcard setup.py)", "")
-	$(BLACK) --check --line-length 120 --safe --target-version py35 setup.py
+	$(BLACK) --check --line-length 120 --safe --target-version py39 setup.py
 endif
 
 .PHONY: lint-flake8
diff --git a/androidtv/exceptions.py b/androidtv/exceptions.py
index 10a3aff6..326e5db4 100644
--- a/androidtv/exceptions.py
+++ b/androidtv/exceptions.py
@@ -1,6 +1,4 @@
-"""Exceptions for use throughout the code.
-
-"""
+"""Exceptions for use throughout the code."""
 
 
 class LockNotAcquiredException(Exception):
diff --git a/tests/test_adb_manager_async.py b/tests/test_adb_manager_async.py
index d17c45e7..7d8c2ced 100644
--- a/tests/test_adb_manager_async.py
+++ b/tests/test_adb_manager_async.py
@@ -173,8 +173,9 @@ async def test_adb_shell_fail_lock_released(self):
         with async_patchers.patch_connect(True)[self.PATCH_KEY], async_patchers.patch_shell("TEST")[self.PATCH_KEY]:
             self.assertTrue(await self.adb.connect())
 
-        with async_patchers.patch_shell("TEST", error=True)[self.PATCH_KEY], patch.object(
-            self.adb, "_adb_lock", AsyncFakeLock()
+        with (
+            async_patchers.patch_shell("TEST", error=True)[self.PATCH_KEY],
+            patch.object(self.adb, "_adb_lock", AsyncFakeLock()),
         ):
             with patch("{}.AsyncFakeLock.release".format(__name__)) as release:
                 with self.assertRaises(Exception):
@@ -261,8 +262,9 @@ async def test_adb_screencap_lock_not_acquired(self):
             self.assertTrue(await self.adb.connect())
             self.assertEqual(await self.adb.shell("TEST"), "TEST")
 
-        with async_patchers.patch_shell(PNG_IMAGE)[self.PATCH_KEY], patch.object(
-            self.adb, "_adb_lock", AsyncLockedLock()
+        with (
+            async_patchers.patch_shell(PNG_IMAGE)[self.PATCH_KEY],
+            patch.object(self.adb, "_adb_lock", AsyncLockedLock()),
         ):
             with patch("{}.AsyncLockedLock.release".format(__name__)) as release:
                 with self.assertRaises(LockNotAcquiredException):
@@ -332,9 +334,11 @@ def setUp(self):
     @awaiter
     async def test_connect_success_with_priv_key(self):
         """Test when the connect attempt is successful when using a private key."""
-        with async_patchers.patch_connect(True)[self.PATCH_KEY], patch(
-            "androidtv.adb_manager.adb_manager_async.aiofiles.open", open_priv
-        ), patch("androidtv.adb_manager.adb_manager_async.PythonRSASigner", return_value="TEST"):
+        with (
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            patch("androidtv.adb_manager.adb_manager_async.aiofiles.open", open_priv),
+            patch("androidtv.adb_manager.adb_manager_async.PythonRSASigner", return_value="TEST"),
+        ):
             self.assertTrue(await self.adb.connect())
             self.assertTrue(self.adb.available)
 
@@ -347,9 +351,11 @@ async def test_connect_success_with_priv_key(self):
     @awaiter
     async def test_connect_success_with_priv_pub_key(self):
         """Test when the connect attempt is successful when using private and public keys."""
-        with async_patchers.patch_connect(True)[self.PATCH_KEY], patch(
-            "androidtv.adb_manager.adb_manager_async.aiofiles.open", open_priv_pub
-        ), patch("androidtv.adb_manager.adb_manager_async.PythonRSASigner", return_value=None):
+        with (
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            patch("androidtv.adb_manager.adb_manager_async.aiofiles.open", open_priv_pub),
+            patch("androidtv.adb_manager.adb_manager_async.PythonRSASigner", return_value=None),
+        ):
             self.assertTrue(await self.adb.connect())
             self.assertTrue(self.adb.available)
 
diff --git a/tests/test_adb_manager_sync.py b/tests/test_adb_manager_sync.py
index 482df913..e67f66c4 100644
--- a/tests/test_adb_manager_sync.py
+++ b/tests/test_adb_manager_sync.py
@@ -295,9 +295,11 @@ def setUp(self):
 
     def test_connect_success_with_priv_key(self):
         """Test when the connect attempt is successful when using a private key."""
-        with patchers.patch_connect(True)[self.PATCH_KEY], patch(
-            "androidtv.adb_manager.adb_manager_sync.open", open_priv
-        ), patch("androidtv.adb_manager.adb_manager_sync.PythonRSASigner", return_value="TEST"):
+        with (
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patch("androidtv.adb_manager.adb_manager_sync.open", open_priv),
+            patch("androidtv.adb_manager.adb_manager_sync.PythonRSASigner", return_value="TEST"),
+        ):
             self.assertTrue(self.adb.connect())
             self.assertTrue(self.adb.available)
 
@@ -309,9 +311,11 @@ def test_connect_success_with_priv_key(self):
 
     def test_connect_success_with_priv_pub_key(self):
         """Test when the connect attempt is successful when using private and public keys."""
-        with patchers.patch_connect(True)[self.PATCH_KEY], patch(
-            "androidtv.adb_manager.adb_manager_sync.open", open_priv_pub
-        ), patch("androidtv.adb_manager.adb_manager_sync.PythonRSASigner", return_value=None):
+        with (
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patch("androidtv.adb_manager.adb_manager_sync.open", open_priv_pub),
+            patch("androidtv.adb_manager.adb_manager_sync.PythonRSASigner", return_value=None),
+        ):
             self.assertTrue(self.adb.connect())
             self.assertTrue(self.adb.available)
 
diff --git a/tests/test_androidtv_async.py b/tests/test_androidtv_async.py
index 98fbc378..9452ffe5 100644
--- a/tests/test_androidtv_async.py
+++ b/tests/test_androidtv_async.py
@@ -62,9 +62,11 @@ class TestAndroidTVAsyncPython(unittest.TestCase):
 
     @awaiter
     async def setUp(self):
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell("")[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.atv = AndroidTVAsync("HOST", 5555)
             await self.atv.adb_connect()
 
@@ -105,11 +107,12 @@ async def test_running_apps(self):
     async def test_stream_music_properties(self):
         """Check that the ``stream_music_properties`` method works correctly."""
         with async_patchers.patch_shell(None)[self.PATCH_KEY]:
-            with patch_calls(self.atv, self.atv._audio_output_device) as audio_output_device, patch_calls(
-                self.atv, self.atv._is_volume_muted
-            ) as is_volume_muted, patch_calls(self.atv, self.atv._volume) as volume, patch_calls(
-                self.atv, self.atv._volume_level
-            ) as volume_level:
+            with (
+                patch_calls(self.atv, self.atv._audio_output_device) as audio_output_device,
+                patch_calls(self.atv, self.atv._is_volume_muted) as is_volume_muted,
+                patch_calls(self.atv, self.atv._volume) as volume,
+                patch_calls(self.atv, self.atv._volume_level) as volume_level,
+            ):
                 await self.atv.stream_music_properties()
                 assert audio_output_device.called
                 assert is_volume_muted.called
@@ -220,51 +223,39 @@ async def test_volume_down(self):
     async def test_get_properties(self):
         """Check that ``get_properties()`` works correctly."""
         with async_patchers.patch_shell(None)[self.PATCH_KEY]:
-            with patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.atv, self.atv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.atv, self.atv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.atv.get_properties(lazy=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert not current_app_media_session_state.called
                 assert not running_apps.called
                 assert not get_hdmi_input.called
 
-            with patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.atv, self.atv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.atv, self.atv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.atv.get_properties(lazy=False, get_running_apps=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
                 assert running_apps.called
                 assert get_hdmi_input.called
 
-            with patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.atv, self.atv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.atv, self.atv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.atv.get_properties(lazy=False, get_running_apps=False)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
diff --git a/tests/test_androidtv_sync.py b/tests/test_androidtv_sync.py
index d74c8ade..5f7626e0 100644
--- a/tests/test_androidtv_sync.py
+++ b/tests/test_androidtv_sync.py
@@ -96,9 +96,11 @@ class TestAndroidTVSyncPython(unittest.TestCase):
     ADB_ATTR = "_adb"
 
     def setUp(self):
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell("")[
-            self.PATCH_KEY
-        ]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.atv = AndroidTVSync("HOST", 5555)
             self.atv.adb_connect()
 
@@ -283,51 +285,51 @@ def test_volume_down(self):
     def test_get_properties(self):
         """Check that ``get_properties()`` works correctly."""
         with patchers.patch_shell(None)[self.PATCH_KEY]:
-            with patchers.patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patchers.patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.atv, self.atv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.atv, self.atv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patchers.patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patchers.patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.atv.get_properties(lazy=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert not current_app_media_session_state.called
                 assert not running_apps.called
                 assert not get_hdmi_input.called
 
-            with patchers.patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patchers.patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.atv, self.atv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.atv, self.atv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patchers.patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patchers.patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.atv.get_properties(lazy=False, get_running_apps=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
                 assert running_apps.called
                 assert get_hdmi_input.called
 
-            with patchers.patch_calls(
-                self.atv, self.atv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.atv, self.atv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.atv, self.atv.stream_music_properties
-            ) as stream_music_properties, patchers.patch_calls(
-                self.atv, self.atv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.atv, self.atv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.atv, self.atv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.atv, self.atv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.atv, self.atv.stream_music_properties) as stream_music_properties,
+                patchers.patch_calls(self.atv, self.atv.running_apps) as running_apps,
+                patchers.patch_calls(self.atv, self.atv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.atv.get_properties(lazy=False, get_running_apps=False)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
diff --git a/tests/test_basetv_async.py b/tests/test_basetv_async.py
index 96f60f88..3a21cdfa 100644
--- a/tests/test_basetv_async.py
+++ b/tests/test_basetv_async.py
@@ -23,9 +23,11 @@ class TestBaseTVAsyncPython(unittest.TestCase):
 
     @awaiter
     async def setUp(self):
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell("")[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.btv = BaseTVAsync("HOST", 5555)
             await self.btv.adb_connect()
 
diff --git a/tests/test_basetv_sync.py b/tests/test_basetv_sync.py
index ce6e7104..93fb1a11 100644
--- a/tests/test_basetv_sync.py
+++ b/tests/test_basetv_sync.py
@@ -198,9 +198,11 @@ class TestBaseTVSyncPython(unittest.TestCase):
     ADB_ATTR = "_adb"
 
     def setUp(self):
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell("")[
-            self.PATCH_KEY
-        ]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.btv = BaseTVSync("HOST", 5555)
             self.btv.adb_connect()
 
diff --git a/tests/test_firetv_async.py b/tests/test_firetv_async.py
index b0aac7a8..6db65429 100644
--- a/tests/test_firetv_async.py
+++ b/tests/test_firetv_async.py
@@ -19,9 +19,11 @@ class TestFireTVAsyncPython(unittest.TestCase):
 
     @awaiter
     async def setUp(self):
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell("")[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.ftv = FireTVAsync("HOST", 5555)
             await self.ftv.adb_connect()
 
@@ -85,45 +87,36 @@ async def test_running_apps(self):
     async def test_get_properties(self):
         """Check that ``get_properties()`` works correctly."""
         with async_patchers.patch_shell(None)[self.PATCH_KEY]:
-            with patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.ftv, self.ftv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.ftv, self.ftv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.ftv.get_properties(lazy=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert not current_app_media_session_state.called
                 assert not running_apps.called
                 assert not get_hdmi_input.called
 
-            with patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.ftv, self.ftv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.ftv, self.ftv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.ftv.get_properties(lazy=False, get_running_apps=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
                 assert running_apps.called
                 assert get_hdmi_input.called
 
-            with patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patch_calls(self.ftv, self.ftv.screen_on_awake_wake_lock_size) as screen_on_awake_wake_lock_size,
+                patch_calls(self.ftv, self.ftv.current_app_media_session_state) as current_app_media_session_state,
+                patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 await self.ftv.get_properties(lazy=False, get_running_apps=False)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
diff --git a/tests/test_firetv_sync.py b/tests/test_firetv_sync.py
index 4faa16c8..bba79c31 100644
--- a/tests/test_firetv_sync.py
+++ b/tests/test_firetv_sync.py
@@ -41,9 +41,11 @@ class TestFireTVSyncPython(unittest.TestCase):
     PATCH_KEY = "python"
 
     def setUp(self):
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell("")[
-            self.PATCH_KEY
-        ]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             self.ftv = FireTVSync("HOST", 5555)
             self.ftv.adb_connect()
 
@@ -109,45 +111,48 @@ def test_running_apps(self):
     def test_get_properties(self):
         """Check that ``get_properties()`` works correctly."""
         with patchers.patch_shell(None)[self.PATCH_KEY]:
-            with patchers.patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.ftv, self.ftv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.ftv, self.ftv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patchers.patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.ftv.get_properties(lazy=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert not current_app_media_session_state.called
                 assert not running_apps.called
                 assert not get_hdmi_input.called
 
-            with patchers.patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.ftv, self.ftv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.ftv, self.ftv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patchers.patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.ftv.get_properties(lazy=False, get_running_apps=True)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
                 assert running_apps.called
                 assert get_hdmi_input.called
 
-            with patchers.patch_calls(
-                self.ftv, self.ftv.screen_on_awake_wake_lock_size
-            ) as screen_on_awake_wake_lock_size, patchers.patch_calls(
-                self.ftv, self.ftv.current_app_media_session_state
-            ) as current_app_media_session_state, patchers.patch_calls(
-                self.ftv, self.ftv.running_apps
-            ) as running_apps, patchers.patch_calls(
-                self.ftv, self.ftv.get_hdmi_input
-            ) as get_hdmi_input:
+            with (
+                patchers.patch_calls(
+                    self.ftv, self.ftv.screen_on_awake_wake_lock_size
+                ) as screen_on_awake_wake_lock_size,
+                patchers.patch_calls(
+                    self.ftv, self.ftv.current_app_media_session_state
+                ) as current_app_media_session_state,
+                patchers.patch_calls(self.ftv, self.ftv.running_apps) as running_apps,
+                patchers.patch_calls(self.ftv, self.ftv.get_hdmi_input) as get_hdmi_input,
+            ):
                 self.ftv.get_properties(lazy=False, get_running_apps=False)
                 assert screen_on_awake_wake_lock_size.called
                 assert current_app_media_session_state.called
diff --git a/tests/test_homeassistant_sync.py b/tests/test_homeassistant_sync.py
index 698ae53c..f5274123 100644
--- a/tests/test_homeassistant_sync.py
+++ b/tests/test_homeassistant_sync.py
@@ -412,9 +412,11 @@ class TestAndroidTVPythonImplementation(unittest.TestCase):
 
     def setUp(self):
         """Set up an `AndroidTVDevice` media player."""
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell("")[
-            self.PATCH_KEY
-        ]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             aftv = setup("HOST", 5555, device_class="androidtv")
             self.aftv = AndroidTVDevice(aftv, "Fake Android TV", {}, True, None, None)
 
@@ -540,9 +542,11 @@ class TestFireTVPythonImplementation(TestAndroidTVPythonImplementation):
 
     def setUp(self):
         """Set up a `FireTVDevice` media player."""
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell("")[
-            self.PATCH_KEY
-        ]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell("")[self.PATCH_KEY],
+        ):
             aftv = setup("HOST", 5555, device_class="firetv")
             self.aftv = FireTVDevice(aftv, "Fake Fire TV", {}, True, None, None)
 
diff --git a/tests/test_setup_async.py b/tests/test_setup_async.py
index 09c33d79..357f7d9b 100644
--- a/tests/test_setup_async.py
+++ b/tests/test_setup_async.py
@@ -47,30 +47,38 @@ async def test_setup(self):
         with self.assertRaises(ValueError):
             await setup("HOST", 5555, device_class="INVALID")
 
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY],
+        ):
             ftv = await setup("HOST", 5555)
             self.assertIsInstance(ftv, FireTVAsync)
             self.assertDictEqual(ftv.device_properties, DEVICE_PROPERTIES_DICT1)
 
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY],
+        ):
             atv = await setup("HOST", 5555)
             self.assertIsInstance(atv, AndroidTVAsync)
             self.assertDictEqual(atv.device_properties, DEVICE_PROPERTIES_DICT2)
 
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY],
+        ):
             ftv = await setup("HOST", 5555, device_class="androidtv")
             self.assertIsInstance(ftv, AndroidTVAsync)
             self.assertDictEqual(ftv.device_properties, DEVICE_PROPERTIES_DICT1)
 
-        with async_patchers.PATCH_ADB_DEVICE_TCP, async_patchers.patch_connect(True)[
-            self.PATCH_KEY
-        ], async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY]:
+        with (
+            async_patchers.PATCH_ADB_DEVICE_TCP,
+            async_patchers.patch_connect(True)[self.PATCH_KEY],
+            async_patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY],
+        ):
             atv = await setup("HOST", 5555, device_class="firetv")
             self.assertIsInstance(atv, FireTVAsync)
             self.assertDictEqual(atv.device_properties, DEVICE_PROPERTIES_DICT2)
diff --git a/tests/test_setup_sync.py b/tests/test_setup_sync.py
index ad9f3105..d136e1b1 100644
--- a/tests/test_setup_sync.py
+++ b/tests/test_setup_sync.py
@@ -50,30 +50,38 @@ def test_setup(self):
         with self.assertRaises(ValueError):
             setup("HOST", 5555, device_class="INVALID")
 
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell(
-            DEVICE_PROPERTIES_OUTPUT1
-        )[self.PATCH_KEY]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY],
+        ):
             ftv = setup("HOST", 5555)
             self.assertIsInstance(ftv, FireTVSync)
             self.assertDictEqual(ftv.device_properties, DEVICE_PROPERTIES_DICT1)
 
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell(
-            DEVICE_PROPERTIES_OUTPUT2
-        )[self.PATCH_KEY]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY],
+        ):
             atv = setup("HOST", 5555)
             self.assertIsInstance(atv, AndroidTVSync)
             self.assertDictEqual(atv.device_properties, DEVICE_PROPERTIES_DICT2)
 
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell(
-            DEVICE_PROPERTIES_OUTPUT1
-        )[self.PATCH_KEY]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT1)[self.PATCH_KEY],
+        ):
             ftv = setup("HOST", 5555, device_class="androidtv")
             self.assertIsInstance(ftv, AndroidTVSync)
             self.assertDictEqual(ftv.device_properties, DEVICE_PROPERTIES_DICT1)
 
-        with patchers.PATCH_ADB_DEVICE_TCP, patchers.patch_connect(True)[self.PATCH_KEY], patchers.patch_shell(
-            DEVICE_PROPERTIES_OUTPUT2
-        )[self.PATCH_KEY]:
+        with (
+            patchers.PATCH_ADB_DEVICE_TCP,
+            patchers.patch_connect(True)[self.PATCH_KEY],
+            patchers.patch_shell(DEVICE_PROPERTIES_OUTPUT2)[self.PATCH_KEY],
+        ):
             atv = setup("HOST", 5555, device_class="firetv")
             self.assertIsInstance(atv, FireTVSync)
             self.assertDictEqual(atv.device_properties, DEVICE_PROPERTIES_DICT2)