bump linting to min python version py3.9 (#597)

* bump linting to min python version py3.9
* fixing

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: Borda

.pre-commit-config.yaml

@@ -47,7 +47,7 @@ repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.12.2
     hooks:
-      - id: ruff-format
-        args: ["--preview"]
       - id: ruff
         args: ["--fix"]
+      - id: ruff-format
+      - id: ruff-check

pyproject.toml

@@ -110,7 +110,7 @@ blank = true
 
 [tool.ruff]
 line-length = 120
-target-version = "py38"
+target-version = "py39"
 # Enable Pyflakes `E` and `F` codes by default.
 lint.select = [
     "E", "W",  # see: https://pypi.org/project/pycodestyle

src/litserve/callbacks/base.py

@@ -1,7 +1,7 @@
 import logging
 from abc import ABC
 from enum import Enum
-from typing import List, Union
+from typing import Union
 
 logger = logging.getLogger(__name__)
 
@@ -62,12 +62,12 @@ def on_response(self, *args, **kwargs):
 
 
 class CallbackRunner:
-    def __init__(self, callbacks: Union[Callback, List[Callback]] = None):
+    def __init__(self, callbacks: Union[Callback, list[Callback]] = None):
         self._callbacks = []
         if callbacks:
             self._add_callbacks(callbacks)
 
-    def _add_callbacks(self, callbacks: Union[Callback, List[Callback]]):
+    def _add_callbacks(self, callbacks: Union[Callback, list[Callback]]):
         if not isinstance(callbacks, list):
             callbacks = [callbacks]
         for callback in callbacks:

src/litserve/connector.py

@@ -16,11 +16,11 @@
 import subprocess
 import sys
 from functools import lru_cache
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 
 class _Connector:
-    def __init__(self, accelerator: str = "auto", devices: Union[List[int], int, str] = "auto"):
+    def __init__(self, accelerator: str = "auto", devices: Union[list[int], int, str] = "auto"):
         accelerator = self._sanitize_accelerator(accelerator)
         if accelerator in ("cpu", "cuda", "mps"):
             self._accelerator = accelerator

src/litserve/loggers.py

@@ -16,7 +16,7 @@
 import multiprocessing as mp
 import pickle
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from starlette.types import ASGIApp
 
@@ -93,7 +93,7 @@ class _LoggerConnector:
 
     """
 
-    def __init__(self, lit_server: "LitServer", loggers: Optional[Union[List[Logger], Logger]] = None):
+    def __init__(self, lit_server: "LitServer", loggers: Optional[Union[list[Logger], Logger]] = None):
         self._loggers = []
         self._lit_server = lit_server
         if loggers is None:
@@ -126,7 +126,7 @@ def _is_picklable(obj):
             return False
 
     @staticmethod
-    def _process_logger_queue(logger_proxies: List[_LoggerProxy], queue):
+    def _process_logger_queue(logger_proxies: list[_LoggerProxy], queue):
         loggers = [proxy if isinstance(proxy, Logger) else proxy.create_logger() for proxy in logger_proxies]
         while True:
             key, value = queue.get()

src/litserve/loops/base.py

@@ -21,7 +21,7 @@
 import time
 from abc import ABC
 from queue import Empty, Queue
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from starlette.formparsers import MultiPartParser
 
@@ -41,7 +41,7 @@
 _SENTINEL_VALUE = (None, None, None, None)
 
 
-def _inject_context(context: Union[List[dict], dict], func, *args, **kwargs):
+def _inject_context(context: Union[list[dict], dict], func, *args, **kwargs):
     sig = inspect.signature(func)
     if "context" in sig.parameters:
         return func(*args, **kwargs, context=context)
@@ -80,7 +80,7 @@ async def _handle_async_function(func, *args, **kwargs):
     return result
 
 
-async def _async_inject_context(context: Union[List[dict], dict], func, *args, **kwargs):
+async def _async_inject_context(context: Union[list[dict], dict], func, *args, **kwargs):
     sig = inspect.signature(func)
 
     # Determine if we need to inject context
@@ -99,7 +99,7 @@ def __init__(self, message: str = _DEFAULT_STOP_LOOP_MESSAGE):
 def collate_requests(
     lit_api: LitAPI,
     request_queue: Queue,
-) -> Tuple[List, List]:
+) -> tuple[list, list]:
     payloads = []
     timed_out_uids = []
     entered_at = time.monotonic()
@@ -170,9 +170,9 @@ def run(
             device: str,
             worker_id: int,
             request_queue: Queue,
-            response_queues: List[Queue],
+            response_queues: list[Queue],
             stream: bool,
-            workers_setup_status: Dict[int, str],
+            workers_setup_status: dict[int, str],
             callback_runner: CallbackRunner,
         ):
             item = request_queue.get()
@@ -198,7 +198,7 @@ async def schedule_task(
         lit_api: LitAPI,
         lit_spec: Optional[LitSpec],
         request_queue: Queue,
-        response_queues: List[Queue],
+        response_queues: list[Queue],
     ):
         pass
 
@@ -209,7 +209,7 @@ def __call__(
         worker_id: int,
         request_queue: Queue,
         transport: MessageTransport,
-        workers_setup_status: Dict[int, str],
+        workers_setup_status: dict[int, str],
         callback_runner: CallbackRunner,
     ):
         lit_spec = lit_api.spec
@@ -255,7 +255,7 @@ def run(
         worker_id: int,
         request_queue: Queue,
         transport: MessageTransport,
-        workers_setup_status: Dict[int, str],
+        workers_setup_status: dict[int, str],
         callback_runner: CallbackRunner,
     ):
         raise NotImplementedError
@@ -279,7 +279,7 @@ def get_batch_requests(
         self,
         lit_api: LitAPI,
         request_queue: Queue,
-    ) -> Tuple[List, List]:
+    ) -> tuple[list, list]:
         batches, timed_out_uids = collate_requests(
             lit_api,
             request_queue,
@@ -330,10 +330,13 @@ def pre_setup(self, lit_api: LitAPI, spec: Optional[LitSpec] = None):
             return
 
         original = lit_api.unbatch.__code__ is LitAPI.unbatch.__code__
-        if not lit_api.stream and any([
-            inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
-            inspect.isgeneratorfunction(lit_api.encode_response) or inspect.isasyncgenfunction(lit_api.encode_response),
-        ]):
+        if not lit_api.stream and any(
+            [
+                inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
+                inspect.isgeneratorfunction(lit_api.encode_response)
+                or inspect.isasyncgenfunction(lit_api.encode_response),
+            ]
+        ):
             raise ValueError(
                 """When `stream=False`, `lit_api.predict`, `lit_api.encode_response` must not be
                 generator or async generator functions.
@@ -366,16 +369,18 @@ async def predict(self, inputs):
         if (
             lit_api.stream
             and lit_api.max_batch_size > 1
-            and not all([
-                inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
-                inspect.isgeneratorfunction(lit_api.encode_response)
-                or inspect.isasyncgenfunction(lit_api.encode_response),
-                (
-                    original
-                    or inspect.isgeneratorfunction(lit_api.unbatch)
-                    or inspect.isasyncgenfunction(lit_api.unbatch)
-                ),
-            ])
+            and not all(
+                [
+                    inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
+                    inspect.isgeneratorfunction(lit_api.encode_response)
+                    or inspect.isasyncgenfunction(lit_api.encode_response),
+                    (
+                        original
+                        or inspect.isgeneratorfunction(lit_api.unbatch)
+                        or inspect.isasyncgenfunction(lit_api.unbatch)
+                    ),
+                ]
+            )
         ):
             raise ValueError(
                 """When `stream=True` with max_batch_size > 1, `lit_api.predict`, `lit_api.encode_response` and
@@ -407,10 +412,13 @@ async def predict(self, inputs):
              """
             )
 
-        if lit_api.stream and not all([
-            inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
-            inspect.isgeneratorfunction(lit_api.encode_response) or inspect.isasyncgenfunction(lit_api.encode_response),
-        ]):
+        if lit_api.stream and not all(
+            [
+                inspect.isgeneratorfunction(lit_api.predict) or inspect.isasyncgenfunction(lit_api.predict),
+                inspect.isgeneratorfunction(lit_api.encode_response)
+                or inspect.isasyncgenfunction(lit_api.encode_response),
+            ]
+        ):
             raise ValueError(
                 """When `stream=True` both `lit_api.predict` and
              `lit_api.encode_response` must generate values using `yield` (can be regular or async generators).

src/litserve/loops/continuous_batching_loop.py

@@ -15,7 +15,7 @@
 import logging
 from dataclasses import dataclass
 from queue import Queue
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 from fastapi import HTTPException
 
@@ -30,15 +30,17 @@
 
 
 def notify_timed_out_requests(
-    response_queues: List[Queue],
-    timed_out_uids: List[Tuple[int, str]],
+    response_queues: list[Queue],
+    timed_out_uids: list[tuple[int, str]],
 ):
     for response_queue_id, uid in timed_out_uids:
         logger.error(f"Request {uid} was waiting in the queue for too long and has been timed out.")
-        response_queues[response_queue_id].put((
-            uid,
-            (HTTPException(504, "Request timed out"), LitAPIStatus.ERROR, LoopResponseType.STREAMING),
-        ))
+        response_queues[response_queue_id].put(
+            (
+                uid,
+                (HTTPException(504, "Request timed out"), LitAPIStatus.ERROR, LoopResponseType.STREAMING),
+            )
+        )
 
 
 @dataclass
@@ -67,9 +69,9 @@ def __init__(self, max_sequence_length: int = 2048):
 
         """
         super().__init__()
-        self.active_sequences: Dict[str, Dict] = {}  # uid -> {input, current_length, generated_sequence}
+        self.active_sequences: dict[str, dict] = {}  # uid -> {input, current_length, generated_sequence}
         self.max_sequence_length = max_sequence_length
-        self.response_queue_ids: Dict[str, int] = {}  # uid -> response_queue_id
+        self.response_queue_ids: dict[str, int] = {}  # uid -> response_queue_id
 
     def pre_setup(self, lit_api: LitAPI, spec: Optional[LitSpec] = None):
         """Check if the lit_api has the necessary methods and if streaming is enabled."""
@@ -119,14 +121,14 @@ def has_capacity(self, lit_api: LitAPI) -> bool:
 
     async def prefill(
         self,
-        pending_requests: List[Tuple[str, Any]],
+        pending_requests: list[tuple[str, Any]],
         lit_api: LitAPI,
         lit_spec: Optional[LitSpec],
         request_queue: Queue,
-        response_queues: List[Queue] = None,
+        response_queues: list[Queue] = None,
         max_batch_size: Optional[int] = None,
         batch_timeout: Optional[float] = None,
-    ) -> List[Tuple[str, Any]]:
+    ) -> list[tuple[str, Any]]:
         """Fill available capacity with pending and new requests."""
         # First process existing pending requests
         while pending_requests and self.has_capacity(lit_api):
@@ -154,7 +156,7 @@ async def schedule_task(
         lit_api: LitAPI,
         lit_spec: Optional[LitSpec],
         request_queue: Queue,
-        response_queues: List[Queue],
+        response_queues: list[Queue],
     ):
         logger.info("Running prefill in background")
         try:
@@ -176,8 +178,8 @@ async def schedule_task(
             logger.info("Exiting run_in_background in continuous_batching_loop")
 
     async def step(
-        self, prev_outputs: Optional[List[Output]], lit_api: LitAPI, lit_spec: Optional[LitSpec]
-    ) -> List[Output]:
+        self, prev_outputs: Optional[list[Output]], lit_api: LitAPI, lit_spec: Optional[LitSpec]
+    ) -> list[Output]:
         return await asyncio.to_thread(lit_api.step, prev_outputs)
 
     async def run(
@@ -187,7 +189,7 @@ async def run(
         worker_id: int,
         request_queue: Queue,
         transport: MessageTransport,
-        workers_setup_status: Dict[int, str],
+        workers_setup_status: dict[int, str],
         callback_runner: CallbackRunner,
     ):
         """Main loop that processes batches of requests."""
@@ -243,8 +245,8 @@ def add_request(self, uid: str, request: Any, lit_api: LitAPI, lit_spec: Optiona
         self.active_sequences[uid] = {"input": decoded_request, "current_length": 0, "generated_sequence": []}
 
     async def step(
-        self, prev_outputs: Optional[List[Output]], lit_api: LitAPI, lit_spec: Optional[LitSpec]
-    ) -> List[Output]:
+        self, prev_outputs: Optional[list[Output]], lit_api: LitAPI, lit_spec: Optional[LitSpec]
+    ) -> list[Output]:
         """Process one token generation step for all active sequences."""
         if not self.active_sequences:
             return []
@@ -255,9 +257,9 @@ async def step(
 
         try:
             # Assume lit_api.predict handles batched token generation
-            new_tokens: List[Any] = lit_api.predict(inputs, generated)
+            new_tokens: list[Any] = lit_api.predict(inputs, generated)
 
-            responses: List[Output] = []
+            responses: list[Output] = []
 
             # Process each sequence's new token
             for uid, token in zip(self.active_sequences.keys(), new_tokens):

src/litserve/loops/loops.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 import logging
 from queue import Queue
-from typing import Dict
 
 from litserve import LitAPI
 from litserve.callbacks import CallbackRunner, EventTypes
@@ -64,7 +63,7 @@ def inference_worker(
     worker_id: int,
     request_queue: Queue,
     transport: MessageTransport,
-    workers_setup_status: Dict[int, str],
+    workers_setup_status: dict[int, str],
     callback_runner: CallbackRunner,
 ):
     lit_spec = lit_api.spec

src/litserve/loops/simple_loops.py

@@ -15,7 +15,7 @@
 import logging
 import time
 from queue import Empty, Queue
-from typing import Dict, Optional
+from typing import Optional
 
 from fastapi import HTTPException
 
@@ -275,7 +275,7 @@ def __call__(
         worker_id: int,
         request_queue: Queue,
         transport: MessageTransport,
-        workers_setup_status: Dict[int, str],
+        workers_setup_status: dict[int, str],
         callback_runner: CallbackRunner,
         lit_spec: Optional[LitSpec] = None,
         stream: bool = False,
@@ -401,7 +401,7 @@ def __call__(
         worker_id: int,
         request_queue: Queue,
         transport: MessageTransport,
-        workers_setup_status: Dict[int, str],
+        workers_setup_status: dict[int, str],
         callback_runner: CallbackRunner,
         lit_spec: Optional[LitSpec] = None,
         stream: bool = False,