chore: Update Python version compatibility to 3.10-3.14

.github/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        python-version: ['3.10', '3.11', '3.12', '3.13', '3.14']
     timeout-minutes: 15
 
     steps:

pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-requires-python = ">=3.9,<3.14"
+requires-python = ">=3.10,<3.15"
 
 dependencies = [
     "cloudpickle>=3.1.1",
@@ -68,7 +68,7 @@ addopts = [
     "--tb=short",
     "--cov=tetra_rp",
     "--cov-report=term-missing",
-    "--cov-fail-under=35"
+    "--cov-fail-under=65"
 ]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
@@ -92,7 +92,7 @@ exclude = [
 
 [tool.mypy]
 # Basic configuration
-python_version = "3.9"
+python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = false  # Start lenient, can be stricter later

src/tetra_rp/core/resources/template.py

@@ -1,7 +1,5 @@
-import warnings
 from typing import Dict, List, Optional, Any
 from pydantic import BaseModel, model_validator
-from tetra_rp.core.utils.http import get_authenticated_requests_session
 from .base import BaseResource
 
 
@@ -36,72 +34,3 @@ class PodTemplate(BaseResource):
     def sync_input_fields(self):
         self.name = f"{self.name}__{self.resource_id}"
         return self
-
-
-def update_system_dependencies(
-    template_id, token=None, system_dependencies=None, base_entry_cmd=None
-):
-    """
-    Updates Runpod template with system dependencies installed via apt-get,
-    and appends the app start command.
-
-    Args:
-        template_id (str): Runpod template ID.
-        token (str): [DEPRECATED] Runpod API token. Ignored; uses RUNPOD_API_KEY env var instead.
-        system_dependencies (List[str]): List of apt packages to install.
-        base_entry_cmd (List[str]): The default command to run the app, e.g. ["uv", "run", "handler.py"]
-    Returns:
-        dict: API response JSON or error info.
-    """
-    # Warn if deprecated token parameter is used
-    if token is not None:
-        warnings.warn(
-            "The 'token' parameter is deprecated and ignored. "
-            "Authentication now uses RUNPOD_API_KEY environment variable.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-    # Compose apt-get install command if any packages specified
-    apt_cmd = ""
-    if system_dependencies:
-        joined_pkgs = " ".join(system_dependencies)
-        apt_cmd = f"apt-get update && apt-get install -y {joined_pkgs} && "
-
-    # Default start command if not provided
-    app_cmd = base_entry_cmd or ["uv", "run", "handler.py"]
-    app_cmd_str = " ".join(app_cmd)
-
-    # Full command to run in entrypoint shell
-    full_cmd = f"{apt_cmd}exec {app_cmd_str}"
-
-    payload = {
-        # other required fields like disk, env, image, etc, should be fetched or passed in real usage
-        "dockerEntrypoint": ["/bin/bash", "-c", full_cmd],
-        "dockerStartCmd": [],
-        # placeholder values, replace as needed or fetch from current template state
-        "containerDiskInGb": 50,
-        "containerRegistryAuthId": "",
-        "env": {},
-        "imageName": "your-image-name",
-        "isPublic": False,
-        "name": "your-template-name",
-        "ports": ["8888/http", "22/tcp"],
-        "readme": "",
-        "volumeInGb": 20,
-        "volumeMountPath": "/workspace",
-    }
-
-    url = f"https://rest.runpod.io/v1/templates/{template_id}/update"
-
-    # Use centralized auth utility instead of manual header setup
-    # Note: token parameter is deprecated; uses RUNPOD_API_KEY environment variable
-    session = get_authenticated_requests_session()
-    try:
-        response = session.post(url, json=payload)
-        response.raise_for_status()
-        return response.json()
-    except Exception as e:
-        return {"error": "Failed to update template", "details": str(e)}
-    finally:
-        session.close()

tests/unit/runtime/test_serialization.py

@@ -0,0 +1,183 @@
+"""Tests for serialization utilities."""
+
+from unittest.mock import patch
+
+import pytest
+
+from tetra_rp.runtime.exceptions import SerializationError
+from tetra_rp.runtime.serialization import (
+    deserialize_arg,
+    deserialize_args,
+    deserialize_kwargs,
+    serialize_arg,
+    serialize_args,
+    serialize_kwargs,
+)
+
+
+class TestSerializeArg:
+    """Test serialize_arg function."""
+
+    def test_serialize_simple_arg(self):
+        """Test serializing a simple argument."""
+        result = serialize_arg(42)
+        assert isinstance(result, str)
+        # Verify it's valid base64
+        import base64
+
+        decoded = base64.b64decode(result)
+        assert len(decoded) > 0
+
+    def test_serialize_raises_on_cloudpickle_error(self):
+        """Test serialize_arg handles cloudpickle errors."""
+        with patch("cloudpickle.dumps") as mock_dumps:
+            mock_dumps.side_effect = RuntimeError("Unexpected cloudpickle error")
+            with pytest.raises(
+                SerializationError, match="Failed to serialize argument"
+            ):
+                serialize_arg(42)
+
+
+class TestSerializeArgs:
+    """Test serialize_args function."""
+
+    def test_serialize_multiple_args(self):
+        """Test serializing multiple arguments."""
+        result = serialize_args((1, "test", [1, 2, 3]))
+        assert len(result) == 3
+        assert all(isinstance(item, str) for item in result)
+
+    def test_serialize_empty_args(self):
+        """Test serializing empty args tuple."""
+        result = serialize_args(())
+        assert result == []
+
+    def test_serialize_args_propagates_serialization_error(self):
+        """Test serialize_args propagates SerializationError."""
+        with patch("tetra_rp.runtime.serialization.serialize_arg") as mock_serialize:
+            mock_serialize.side_effect = SerializationError("Known error")
+            with pytest.raises(SerializationError, match="Known error"):
+                serialize_args((1, 2))
+
+    def test_serialize_args_unexpected_error(self):
+        """Test serialize_args handles unexpected exceptions."""
+        with patch("tetra_rp.runtime.serialization.serialize_arg") as mock_serialize:
+            mock_serialize.side_effect = RuntimeError("Unexpected error")
+            with pytest.raises(SerializationError, match="Failed to serialize args"):
+                serialize_args((1, 2))
+
+
+class TestSerializeKwargs:
+    """Test serialize_kwargs function."""
+
+    def test_serialize_kwargs(self):
+        """Test serializing keyword arguments."""
+        result = serialize_kwargs({"key1": 42, "key2": "test"})
+        assert len(result) == 2
+        assert "key1" in result
+        assert "key2" in result
+        assert all(isinstance(v, str) for v in result.values())
+
+    def test_serialize_empty_kwargs(self):
+        """Test serializing empty kwargs dict."""
+        result = serialize_kwargs({})
+        assert result == {}
+
+    def test_serialize_kwargs_propagates_serialization_error(self):
+        """Test serialize_kwargs propagates SerializationError."""
+        with patch("tetra_rp.runtime.serialization.serialize_arg") as mock_serialize:
+            mock_serialize.side_effect = SerializationError("Known error")
+            with pytest.raises(SerializationError, match="Known error"):
+                serialize_kwargs({"key": 42})
+
+    def test_serialize_kwargs_unexpected_error(self):
+        """Test serialize_kwargs handles unexpected exceptions."""
+        with patch("tetra_rp.runtime.serialization.serialize_arg") as mock_serialize:
+            mock_serialize.side_effect = RuntimeError("Unexpected error")
+            with pytest.raises(SerializationError, match="Failed to serialize kwargs"):
+                serialize_kwargs({"key": 42})
+
+
+class TestDeserializeArg:
+    """Test deserialize_arg function."""
+
+    def test_deserialize_simple_arg(self):
+        """Test deserializing a simple argument."""
+        # First serialize something
+        serialized = serialize_arg(42)
+        # Then deserialize it
+        result = deserialize_arg(serialized)
+        assert result == 42
+
+    def test_deserialize_raises_on_invalid_base64(self):
+        """Test deserialize_arg raises on invalid base64."""
+        with pytest.raises(SerializationError, match="Failed to deserialize argument"):
+            deserialize_arg("not-valid-base64!!!")
+
+
+class TestDeserializeArgs:
+    """Test deserialize_args function."""
+
+    def test_deserialize_multiple_args(self):
+        """Test deserializing multiple arguments."""
+        serialized = serialize_args((1, "test", [1, 2, 3]))
+        result = deserialize_args(serialized)
+        assert result == [1, "test", [1, 2, 3]]
+
+    def test_deserialize_empty_args(self):
+        """Test deserializing empty args list."""
+        result = deserialize_args([])
+        assert result == []
+
+    def test_deserialize_args_propagates_serialization_error(self):
+        """Test deserialize_args propagates SerializationError."""
+        with patch(
+            "tetra_rp.runtime.serialization.deserialize_arg"
+        ) as mock_deserialize:
+            mock_deserialize.side_effect = SerializationError("Known error")
+            with pytest.raises(SerializationError, match="Known error"):
+                deserialize_args(["arg1", "arg2"])
+
+    def test_deserialize_args_unexpected_error(self):
+        """Test deserialize_args handles unexpected exceptions."""
+        with patch(
+            "tetra_rp.runtime.serialization.deserialize_arg"
+        ) as mock_deserialize:
+            mock_deserialize.side_effect = RuntimeError("Unexpected error")
+            with pytest.raises(SerializationError, match="Failed to deserialize args"):
+                deserialize_args(["arg1", "arg2"])
+
+
+class TestDeserializeKwargs:
+    """Test deserialize_kwargs function."""
+
+    def test_deserialize_kwargs(self):
+        """Test deserializing keyword arguments."""
+        serialized = serialize_kwargs({"key1": 42, "key2": "test"})
+        result = deserialize_kwargs(serialized)
+        assert result == {"key1": 42, "key2": "test"}
+
+    def test_deserialize_empty_kwargs(self):
+        """Test deserializing empty kwargs dict."""
+        result = deserialize_kwargs({})
+        assert result == {}
+
+    def test_deserialize_kwargs_propagates_serialization_error(self):
+        """Test deserialize_kwargs propagates SerializationError."""
+        with patch(
+            "tetra_rp.runtime.serialization.deserialize_arg"
+        ) as mock_deserialize:
+            mock_deserialize.side_effect = SerializationError("Known error")
+            with pytest.raises(SerializationError, match="Known error"):
+                deserialize_kwargs({"key": "value"})
+
+    def test_deserialize_kwargs_unexpected_error(self):
+        """Test deserialize_kwargs handles unexpected exceptions."""
+        with patch(
+            "tetra_rp.runtime.serialization.deserialize_arg"
+        ) as mock_deserialize:
+            mock_deserialize.side_effect = RuntimeError("Unexpected error")
+            with pytest.raises(
+                SerializationError, match="Failed to deserialize kwargs"
+            ):
+                deserialize_kwargs({"key": "value"})