feat: support Python 3.10-3.14, drop EOL 3.8/3.9 (#512)

* feat: support Python 3.10-3.14, drop EOL 3.8/3.9

Python 3.8 (EOL 2024-10) and 3.9 (EOL 2025-10) are end-of-life;
advertising support for them was a false security claim. Raise the
supported floor to 3.10 and declare/test through 3.14.

- requires-python / python_requires: >=3.10
- classifiers: 3.10-3.14
- CI test matrix: 3.10, 3.11, 3.12, 3.13, 3.14
- README / ARCHITECTURE: reflect new support range

Floor stays at 3.10 (not 3.11) because GPU/ML base images still ship
3.10/3.11; plan a 3.10->3.11 bump after 3.10 EOL (2026-10).

Refs SLS-265

* test: don't fail on nest_asyncio deprecation under Python 3.14

Adding 3.14 to the CI matrix surfaced a collection error: nest_asyncio
(a test-only dependency) calls the deprecated asyncio.get_event_loop_policy,
and pytest's -W error promoted the DeprecationWarning to a hard error,
interrupting collection of test_worker.py. The SDK runtime does not use
that API, so this is purely test infrastructure.

Move the warnings config from addopts (-W error) into a filterwarnings
list so an ignore for this specific third-party message takes precedence
while all other warnings remain errors.

Refs SLS-265

* test: modernize async worker tests for Python 3.14

nest_asyncio.apply() ran at import and globally patched asyncio; on
Python 3.14 the patched loop breaks current_task(), so asyncio.timeout
(used by asyncio.wait_for in the GPU fitness check) raised "Timeout
should be used inside a task" and failed collection/run for any test
touching it. The SDK runtime itself is 3.14-clean (plain asyncio.run
provides the task context).

- Remove nest_asyncio entirely and drop it from test deps. Convert the
  worker test classes from IsolatedAsyncioTestCase to TestCase: their
  bodies call runpod.serverless.start() synchronously (as production
  does), so run_worker's internal asyncio.run() no longer nests inside a
  running loop and needs no patching.
- Stub run_fitness_checks in TestRunWorker.setUp so unit tests don't run
  real GPU/memory probes (covered by test_modules/test_fitness/).
- test_download_files_from_urls: assert the set of requested URLs, not
  positional call order, since downloads run in parallel threads.

Refs SLS-265

* test: ignore backoff's asyncio.iscoroutinefunction warning on 3.14

The backoff dependency calls asyncio.iscoroutinefunction in its
on_exception decorator; Python 3.14 deprecates it (removal in 3.16).
The SDK's own code uses inspect.iscoroutinefunction, and at runtime this
is only a warning. Filter it (alongside the existing get_event_loop_policy
ignore) so warnings-as-errors doesn't fail the suite until backoff updates.

Refs SLS-265

* docs: bump ARCHITECTURE.md Last Updated for Python support change

Addresses Copilot review: the Python support range was changed without
updating the document's Last Updated header.

Refs SLS-265

Author: deanq

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
       - uses: actions/checkout@v6
 

ARCHITECTURE.md

@@ -1,8 +1,8 @@
 # Runpod Serverless Module Architecture
 
-**Last Updated**: 2025-12-13
+**Last Updated**: 2026-06-18
 **Module**: `runpod/serverless/`
-**Python Support**: 3.8-3.11
+**Python Support**: 3.10-3.14
 
 ---
 
@@ -1467,4 +1467,4 @@ stateDiagram-v2
 ---
 
 **Document Version**: 1.0
-**Last Updated**: 2025-12-13
+**Last Updated**: 2026-06-18

README.md

@@ -63,7 +63,7 @@ cd runpod-python
 pip install -e .
 ```
 
-*Python 3.8 or higher is required to use the latest version of this package.*
+*Python 3.10 or higher is required to use the latest version of this package.*
 
 ## ⚡ | Serverless Worker (SDK)
 

pyproject.toml

@@ -3,7 +3,7 @@ name = "runpod"
 dynamic = ["version", "dependencies"]
 description = "🐍 | Python library for Runpod API and serverless worker SDK."
 readme = { file = "README.md", content-type = "text/markdown" }
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = { text = "MIT License" }
 authors = [
     { name = "Runpod", email = "engineer@runpod.io" },
@@ -25,10 +25,11 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Internet :: WWW/HTTP",
     "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
 ]
@@ -69,7 +70,6 @@ dev = [
 ]
 test = [
     "asynctest",
-    "nest_asyncio",
     "faker",
     "pytest-asyncio",
     "pytest-cov",

pytest.ini

@@ -1,5 +1,12 @@
 [pytest]
-addopts = --durations=10 --cov-config=.coveragerc --timeout=120 --timeout_method=thread --cov=runpod --cov-report=xml --cov-report=term-missing --cov-fail-under=90 -W error -p no:cacheprovider -p no:unraisableexception
+addopts = --durations=10 --cov-config=.coveragerc --timeout=120 --timeout_method=thread --cov=runpod --cov-report=xml --cov-report=term-missing --cov-fail-under=90 -p no:cacheprovider -p no:unraisableexception
+filterwarnings =
+    error
+    # Third-party deps (e.g. backoff) still call asyncio APIs that 3.14 deprecates
+    # and slates for removal in 3.16. The SDK's own code does not; at runtime these
+    # only warn. Don't fail the suite on them until the deps update.
+    ignore:'asyncio\.get_event_loop_policy' is deprecated:DeprecationWarning
+    ignore:'asyncio\.iscoroutinefunction' is deprecated:DeprecationWarning
 python_files = tests.py test_*.py *_test.py
 norecursedirs = venv *.egg-info .git build tests/e2e
 asyncio_mode = auto

setup.py

@@ -34,7 +34,7 @@
         install_requires=install_requires,
         extras_require=extras_require,
         packages=find_packages(),
-        python_requires=">=3.8",
+        python_requires=">=3.10",
         description="🐍 | Python library for Runpod API and serverless worker SDK.",
         long_description=long_description,
         long_description_content_type="text/markdown",

tests/test_serverless/test_utils/test_download.py

@@ -95,10 +95,14 @@ def test_download_files_from_urls(self, mock_open_file, mock_get, mock_makedirs)
 
         self.assertEqual(len(downloaded_files), len(urls))
 
-        for index, url in enumerate(urls):
-            # Check that the url was called with SyncClientSession.get
-            self.assertIn(url, mock_get.call_args_list[index][0])
-
+        # Downloads run in parallel threads, so the order of get() calls is
+        # non-deterministic; assert the set of requested URLs instead of order.
+        requested_urls = {call.args[0] for call in mock_get.call_args_list}
+        self.assertEqual(requested_urls, set(urls))
+
+        # executor.map preserves input order in results, so downloaded_files
+        # still aligns positionally with urls.
+        for index in range(len(urls)):
             # Check that the file has the correct extension
             self.assertTrue(downloaded_files[index].endswith(".jpg"))
 

tests/test_serverless/test_worker.py

@@ -6,23 +6,19 @@
 import os
 import sys
 from unittest import mock
-from unittest.mock import patch, mock_open, Mock, MagicMock
-
-from unittest import IsolatedAsyncioTestCase
-import nest_asyncio
+from unittest import TestCase
+from unittest.mock import patch, mock_open, Mock, MagicMock, AsyncMock
 
 import runpod
 from runpod.serverless.modules.rp_logger import RunPodLogger
 from runpod.serverless.modules.rp_scale import _handle_uncaught_exception
 from runpod.serverless import _signal_handler
 
-nest_asyncio.apply()
-
 
-class TestWorker(IsolatedAsyncioTestCase):
+class TestWorker(TestCase):
     """Tests for Runpod serverless worker."""
 
-    async def asyncSetUp(self):
+    def setUp(self):
         self.mock_handler = mock.Mock(return_value="test")
         self.mock_config = {
             "handler": self.mock_handler,
@@ -105,10 +101,10 @@ def test_signal_handler(self, mock_exit, mock_logger):
         assert mock_logger.info.called
 
 
-class TestWorkerTestInput(IsolatedAsyncioTestCase):
+class TestWorkerTestInput(TestCase):
     """Tests for runpod | serverless| worker"""
 
-    async def asyncSetUp(self):
+    def setUp(self):
         self.mock_handler = Mock()
         self.mock_handler.return_value = {}
 
@@ -176,28 +172,38 @@ def test_generator_handler_exception():
         assert True, "Exception was caught as expected"
 
 
-class TestRunWorker(IsolatedAsyncioTestCase):
+class TestRunWorker(TestCase):
     """Tests for runpod | serverless| worker"""
 
-    async def asyncSetUp(self):
+    def setUp(self):
         os.environ["RUNPOD_WEBHOOK_GET_JOB"] = "https://test.com"
 
+        # run_worker() runs real fitness checks (GPU/memory probes) that exit the
+        # process when unmet; they have dedicated coverage in
+        # test_modules/test_fitness/. Stub them so these tests are deterministic
+        # regardless of host state.
+        fitness_patcher = patch(
+            "runpod.serverless.worker.run_fitness_checks", new=AsyncMock()
+        )
+        fitness_patcher.start()
+        self.addCleanup(fitness_patcher.stop)
+
         # Set up the config
         self.config = {
             "handler": MagicMock(),
             "refresh_worker": True,
             "rp_args": {"rp_debugger": True, "rp_log_level": "DEBUG"},
         }
 
-    async def asyncTearDown(self):
+    def tearDown(self):
         sys.excepthook = sys.__excepthook__
 
     @patch("runpod.serverless.modules.rp_scale.AsyncClientSession")
     @patch("runpod.serverless.modules.rp_scale.get_job")
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker(
+    def test_run_worker(
         self,
         mock_send_result,
         mock_stream_result,
@@ -228,7 +234,7 @@ async def test_run_worker(
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker_generator_handler(
+    def test_run_worker_generator_handler(
         self, mock_send_result, mock_stream_result, mock_run_job, mock_get_job
     ):
         """
@@ -258,7 +264,7 @@ async def test_run_worker_generator_handler(
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker_generator_handler_exception(
+    def test_run_worker_generator_handler_exception(
         self, mock_send_result, mock_stream_result, mock_run_job, mock_get_job
     ):
         """
@@ -303,7 +309,7 @@ async def test_run_worker_generator_handler_exception(
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker_generator_aggregate_handler(
+    def test_run_worker_generator_aggregate_handler(
         self, mock_send_result, mock_stream_result, mock_run_job, mock_get_job
     ):
         """
@@ -343,7 +349,7 @@ async def test_run_worker_generator_aggregate_handler(
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker_concurrency(
+    def test_run_worker_concurrency(
         self,
         mock_send_result,
         mock_stream_result,
@@ -420,7 +426,7 @@ def concurrency_modifier(current_concurrency):
     @patch("runpod.serverless.modules.rp_job.run_job")
     @patch("runpod.serverless.modules.rp_job.stream_result")
     @patch("runpod.serverless.modules.rp_job.send_result")
-    async def test_run_worker_multi_processing(
+    def test_run_worker_multi_processing(
         self,
         mock_send_result,
         mock_stream_result,
@@ -480,7 +486,7 @@ async def test_run_worker_multi_processing(
 
     @patch("runpod.serverless.modules.rp_scale.get_job")
     @patch("runpod.serverless.modules.rp_job.run_job")
-    async def test_run_worker_multi_processing_scaling_up(
+    def test_run_worker_multi_processing_scaling_up(
         self, mock_run_job, mock_get_job
     ):
         """