♻️ fix 3.9 support

Author: shroominic

.github/workflows/auto-tests.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: eifinger/setup-rye@v1
         with:
-          python-version: 3.10
+          python-version: 3.9
           enable_cache: true
           cache_prefix: "venv-codeboxapi"
       - run: rye sync

.github/workflows/code-check.yml

@@ -6,7 +6,7 @@ jobs:
   pre-commit:
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -18,8 +18,6 @@ jobs:
         run: rye pin ${{ matrix.python-version }}
       - name: Sync rye
         run: rye sync
-      - name: Run ruff
-        run: rye run ruff check
       - name: Run tests
         env:
           CODEBOX_API_KEY: ${{ secrets.CODEBOX_API_KEY }}

.github/workflows/docs.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.10
+          python-version: 3.9
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
       - uses: actions/cache@v3
         with:

.github/workflows/python-publish.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v3
         with:
-          python-version: "3.10"
+          python-version: "3.9"
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip

examples/plot_dataset.py

@@ -11,7 +11,7 @@
 
 # download the iris dataset
 iris_csv_bytes = httpx.get(
-    "https://archive.ics.uci.edu/" "ml/machine-learning-databases/iris/iris.data"
+    "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
 ).content
 
 # upload the dataset to the codebox

requirements.lock

@@ -7,6 +7,7 @@
 #   all-features: false
 #   with-sources: false
 #   generate-hashes: false
+#   universal: false
 
 -e file:.
 anyio==4.6.2.post1

src/codeboxapi/api.py

@@ -1,25 +1,27 @@
 import asyncio
 from contextlib import asynccontextmanager
-from datetime import UTC, datetime, timedelta
+from datetime import datetime, timedelta
 from os import getenv, path
-from typing import AsyncGenerator, Literal
+import typing as t
 
 from fastapi import Body, Depends, FastAPI, HTTPException, UploadFile
 from fastapi.responses import FileResponse, StreamingResponse
 from pydantic import BaseModel
 
+from codeboxapi.utils import async_raise_timeout
+
 from .local import LocalBox
 
 codebox = LocalBox()
-last_interaction = datetime.now(UTC)
+last_interaction = datetime.utcnow()
 
 
 @asynccontextmanager
-async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
+async def lifespan(_: FastAPI) -> t.AsyncGenerator[None, None]:
     async def timeout():
         if (_timeout := getenv("CODEBOX_TIMEOUT", "15")).lower() == "none":
             return
-        while last_interaction + timedelta(minutes=float(_timeout)) > datetime.now(UTC):
+        while last_interaction + timedelta(minutes=float(_timeout)) > datetime.utcnow():
             await asyncio.sleep(1)
         exit(0)
 
@@ -28,9 +30,9 @@ async def timeout():
     t.cancel()
 
 
-async def get_codebox() -> AsyncGenerator[LocalBox, None]:
+async def get_codebox() -> t.AsyncGenerator[LocalBox, None]:
     global codebox, last_interaction
-    last_interaction = datetime.now(UTC)
+    last_interaction = datetime.utcnow()
     yield codebox
 
 
@@ -40,16 +42,16 @@ async def get_codebox() -> AsyncGenerator[LocalBox, None]:
 
 class ExecBody(BaseModel):
     code: str
-    kernel: Literal["ipython", "bash"] = "ipython"
-    timeout: int | None = None
-    cwd: str | None = None
+    kernel: t.Literal["ipython", "bash"] = "ipython"
+    timeout: t.Optional[int] = None
+    cwd: t.Optional[str] = None
 
 
 @app.post("/exec")
 async def exec(
     exec: ExecBody, codebox: LocalBox = Depends(get_codebox)
 ) -> StreamingResponse:
-    async def event_stream() -> AsyncGenerator[str, None]:
+    async def event_stream() -> t.AsyncGenerator[str, None]:
         async for chunk in codebox.astream_exec(
             exec.code, exec.kernel, exec.timeout, exec.cwd
         ):  # protocol is <type>content</type>
@@ -61,10 +63,10 @@ async def event_stream() -> AsyncGenerator[str, None]:
 @app.get("/files/download/{file_name}")
 async def download(
     file_name: str,
-    timeout: int | None = None,
+    timeout: t.Optional[int] = None,
     codebox: LocalBox = Depends(get_codebox),
 ) -> FileResponse:
-    async with asyncio.timeout(timeout):
+    async with async_raise_timeout(timeout):
         file_path = path.join(codebox.cwd, file_name)
         return FileResponse(
             path=file_path, media_type="application/octet-stream", filename=file_name
@@ -74,13 +76,13 @@ async def download(
 @app.post("/files/upload")
 async def upload(
     file: UploadFile,
-    timeout: int | None = None,
+    timeout: t.Optional[int] = None,
     codebox: LocalBox = Depends(get_codebox),
 ) -> None:
     if not file.filename:
         raise HTTPException(status_code=400, detail="A file name is required")
-    async with asyncio.timeout(timeout):
-        await codebox.aupload(file.filename, file.file)
+
+    await codebox.aupload(file.filename, file.file, timeout)
 
 
 @app.post("/code/execute")

src/codeboxapi/codebox.py

@@ -50,9 +50,9 @@
 class CodeBox:
     def __new__(
         cls,
-        session_id: str | None = None,
-        api_key: str | t.Literal["local", "docker"] | None = None,
-        factory_id: str | t.Literal["default"] | None = None,
+        session_id: t.Optional[str] = None,
+        api_key: t.Optional[t.Union[str, t.Literal["local", "docker"]]] = None,
+        factory_id: t.Optional[t.Union[str, t.Literal["default"]]] = None,
     ) -> "CodeBox":
         """
         Creates a CodeBox session
@@ -68,9 +68,9 @@ def __new__(
 
     def __init__(
         self,
-        session_id: str | None = None,
-        api_key: str | t.Literal["local", "docker"] | None = None,
-        factory_id: str | t.Literal["default"] | None = None,
+        session_id: t.Optional[str] = None,
+        api_key: t.Optional[t.Union[str, t.Literal["local", "docker"]]] = None,
+        factory_id: t.Optional[t.Union[str, t.Literal["default"]]] = None,
         **_: bool,
     ) -> None:
         self.session_id = session_id or "local"
@@ -81,37 +81,37 @@ def __init__(
 
     def exec(
         self,
-        code: str | os.PathLike,
+        code: t.Union[str, os.PathLike],
         kernel: t.Literal["ipython", "bash"] = "ipython",
-        timeout: float | None = None,
-        cwd: str | None = None,
+        timeout: t.Optional[float] = None,
+        cwd: t.Optional[str] = None,
     ) -> "ExecResult":
         """Execute code inside the CodeBox instance"""
         return flatten_exec_result(self.stream_exec(code, kernel, timeout, cwd))
 
     def stream_exec(
         self,
-        code: str | os.PathLike,
+        code: t.Union[str, os.PathLike],
         kernel: t.Literal["ipython", "bash"] = "ipython",
-        timeout: float | None = None,
-        cwd: str | None = None,
+        timeout: t.Optional[float] = None,
+        cwd: t.Optional[str] = None,
     ) -> t.Generator["ExecChunk", None, None]:
         """Executes the code and streams the result."""
         raise NotImplementedError("Abstract method, please use a subclass.")
 
     def upload(
         self,
         remote_file_path: str,
-        content: t.BinaryIO | bytes | str,
-        timeout: float | None = None,
+        content: t.Union[t.BinaryIO, bytes, str],
+        timeout: t.Optional[float] = None,
     ) -> "RemoteFile":
         """Upload a file to the CodeBox instance"""
         raise NotImplementedError("Abstract method, please use a subclass.")
 
     def stream_download(
         self,
         remote_file_path: str,
-        timeout: float | None = None,
+        timeout: t.Optional[float] = None,
     ) -> t.Generator[bytes, None, None]:
         """Download a file as open BinaryIO. Make sure to close the file after use."""
         raise NotImplementedError("Abstract method, please use a subclass.")
@@ -120,10 +120,10 @@ def stream_download(
 
     async def aexec(
         self,
-        code: str | os.PathLike,
+        code: t.Union[str, os.PathLike],
         kernel: t.Literal["ipython", "bash"] = "ipython",
-        timeout: float | None = None,
-        cwd: str | None = None,
+        timeout: t.Optional[float] = None,
+        cwd: t.Optional[str] = None,
     ) -> "ExecResult":
         """Async Execute python code inside the CodeBox instance"""
         return await async_flatten_exec_result(
@@ -132,34 +132,34 @@ async def aexec(
 
     def astream_exec(
         self,
-        code: str | os.PathLike,
+        code: t.Union[str, os.PathLike],
         kernel: t.Literal["ipython", "bash"] = "ipython",
-        timeout: float | None = None,
-        cwd: str | None = None,
+        timeout: t.Optional[float] = None,
+        cwd: t.Optional[str] = None,
     ) -> t.AsyncGenerator["ExecChunk", None]:
         """Async Stream Chunks of Execute python code inside the CodeBox instance"""
         raise NotImplementedError("Abstract method, please use a subclass.")
 
     async def aupload(
         self,
         remote_file_path: str,
-        content: t.BinaryIO | bytes | str,
-        timeout: float | None = None,
+        content: t.Union[t.BinaryIO, bytes, str],
+        timeout: t.Optional[float] = None,
     ) -> "RemoteFile":
         """Async Upload a file to the CodeBox instance"""
         raise NotImplementedError("Abstract method, please use a subclass.")
 
     async def adownload(
         self,
         remote_file_path: str,
-        timeout: float | None = None,
+        timeout: t.Optional[float] = None,
     ) -> "RemoteFile":
         return [f for f in (await self.alist_files()) if f.path in remote_file_path][0]
 
     def astream_download(
         self,
         remote_file_path: str,
-        timeout: float | None = None,
+        timeout: t.Optional[float] = None,
     ) -> t.AsyncGenerator[bytes, None]:
         """Async Download a file as BinaryIO. Make sure to close the file after use."""
         raise NotImplementedError("Abstract method, please use a subclass.")
@@ -242,7 +242,7 @@ async def ping(cb: CodeBox, d: int) -> None:
     # SYNCIFY
 
     def download(
-        self, remote_file_path: str, timeout: float | None = None
+        self, remote_file_path: str, timeout: t.Optional[float] = None
     ) -> "RemoteFile":
         return syncify(self.adownload)(remote_file_path, timeout)
 
@@ -288,7 +288,7 @@ async def astop(self) -> t.Literal["stopped"]:
     @deprecated(
         "The `.run` method is deprecated. Use `.exec` instead.",
     )
-    async def arun(self, code: str | os.PathLike) -> "CodeBoxOutput":
+    async def arun(self, code: t.Union[str, os.PathLike]) -> "CodeBoxOutput":
         from .types import CodeBoxOutput
 
         exec_result = await self.aexec(code, kernel="ipython")
@@ -321,7 +321,7 @@ def stop(self) -> t.Literal["stopped"]:
     @deprecated(
         "The `.run` method is deprecated. Use `.exec` instead.",
     )
-    def run(self, code: str | os.PathLike) -> "CodeBoxOutput":
+    def run(self, code: t.Union[str, os.PathLike]) -> "CodeBoxOutput":
         return syncify(self.arun)(code)
 
     @deprecated(

src/codeboxapi/docker.py

@@ -1,13 +1,14 @@
 import socket
 import subprocess
 import time
+import typing as t
 
 import httpx
 
 from .remote import RemoteBox
 
 
-def get_free_port(port_or_range: int | tuple[int, int]) -> int:
+def get_free_port(port_or_range: t.Union[int, t.Tuple[int, int]]) -> int:
     if isinstance(port_or_range, int):
         port = port_or_range
     else:
@@ -29,7 +30,7 @@ def get_free_port(port_or_range: int | tuple[int, int]) -> int:
 class DockerBox(RemoteBox):
     def __init__(
         self,
-        port_or_range: int | tuple[int, int] = 8069,
+        port_or_range: t.Union[int, t.Tuple[int, int]] = 8069,
         image: str = "shroominic/codebox:latest",
         timeout: float = 3,  # minutes
         start_container: bool = True,