chore: update project structure and dependencies

- Update test files moved to src/ directory
- Enhanced test coverage for acceleration features
- Updated dependencies and documentation
- Submodule updates for tetra-rp

pyproject.toml

@@ -7,6 +7,7 @@ requires-python = ">=3.9,<3.13"
 dependencies = [
     "cloudpickle>=3.1.1",
     "pydantic>=2.11.4",
+    "requests>=2.25.0",
     "runpod",
 ]
 
@@ -18,6 +19,7 @@ dev = [
     "pytest-asyncio>=0.24.0",
     "ruff>=0.8.0",
     "mypy>=1.11.0",
+    "types-requests>=2.25.0",
 ]
 
 [tool.pytest.ini_options]
@@ -48,40 +50,35 @@ filterwarnings = [
     "ignore::pytest.PytestUnknownMarkWarning"
 ]
 
-[tool.ruff]
-# Exclude tetra-rp directory since it's a separate repository
-exclude = [
-    "tetra-rp/",
-]
-
 [tool.mypy]
-# Basic configuration
 python_version = "3.9"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = false  # Start lenient, can be stricter later
-disallow_incomplete_defs = false
-check_untyped_defs = true
-
-# Import discovery
 mypy_path = ["src"]
+explicit_package_bases = true
 namespace_packages = true
-
-# Error output
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_untyped_defs = false
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_return_any = true
+strict_optional = true
 show_error_codes = true
 show_column_numbers = true
 pretty = true
-
-# Exclude directories
 exclude = [
     "tetra-rp/",
-    "tests/",  # Start by excluding tests, can add later
 ]
 
-# Per-module options
 [[tool.mypy.overrides]]
 module = [
-    "runpod.*",
-    "cloudpickle.*",
+    "cloudpickle",
+    "runpod",
+    "transformers",
 ]
 ignore_missing_imports = true
+
+[tool.ruff]
+# Exclude tetra-rp directory since it's a separate repository
+exclude = [
+    "tetra-rp/",
+]

src/class_executor.py

@@ -18,7 +18,7 @@ def __init__(self, workspace_manager):
         super().__init__(workspace_manager)
         # Instance registry for persistent class instances
         self.class_instances: Dict[str, Any] = {}
-        self.instance_metadata: Dict[str, Dict] = {}
+        self.instance_metadata: Dict[str, Dict[str, Any]] = {}
 
     def execute(self, request: FunctionRequest) -> FunctionResponse:
         """Execute class method - required by BaseExecutor interface."""

src/handler.py

@@ -1,6 +1,7 @@
 import runpod
 import logging
 import sys
+from typing import Dict, Any
 
 from remote_execution import FunctionRequest, FunctionResponse
 from remote_executor import RemoteExecutor
@@ -13,7 +14,7 @@
 )
 
 
-async def handler(event: dict) -> dict:
+async def handler(event: Dict[str, Any]) -> Dict[str, Any]:
     """
     RunPod serverless function handler with dependency installation.
     """

tests/integration/test_dependency_management.py

@@ -128,14 +128,20 @@ def test_with_deps():
                 "obj", (object,), {"success": True, "stdout": "python deps installed"}
             )()
             mock_execute.return_value = type(
-                "obj", (object,), {"success": True, "result": "encoded_result"}
+                "obj",
+                (object,),
+                {
+                    "success": True,
+                    "result": "encoded_result",
+                    "stdout": "function executed",
+                },
             )()
 
             result = await executor.ExecuteFunction(request)
 
             # Verify all steps were called
             mock_sys_deps.assert_called_once_with(["curl"])
-            mock_py_deps.assert_called_once_with(["requests"])
+            mock_py_deps.assert_called_once_with(["requests"], True)
             mock_execute.assert_called_once_with(request)
 
             assert result.success is True

tests/integration/test_handler_integration.py

@@ -13,7 +13,7 @@ class TestHandlerIntegration:
 
     def setup_method(self):
         """Setup for each test method."""
-        self.test_data_dir = Path(__file__).parent.parent.parent
+        self.test_data_dir = Path(__file__).parent.parent.parent / "src"
         self.test_input_file = self.test_data_dir / "test_input.json"
         self.test_class_input_file = self.test_data_dir / "test_class_input.json"
 

tests/integration/test_runpod_volume_integration.py

@@ -4,16 +4,31 @@
 import base64
 import cloudpickle
 import threading
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, patch, MagicMock
 
-from handler import RemoteExecutor, handler
-from remote_execution import FunctionResponse
-from constants import RUNPOD_VOLUME_PATH, VENV_DIR_NAME, RUNTIMES_DIR_NAME
+from src.handler import RemoteExecutor, handler
+from src.remote_execution import FunctionResponse
+from src.constants import RUNPOD_VOLUME_PATH, VENV_DIR_NAME, RUNTIMES_DIR_NAME
 
 
 class TestFullWorkflowWithVolume:
     """Test complete request workflows with volume integration."""
 
+    def setup_method(self):
+        # Patch subprocess.run globally for all tests in this class
+        class ContextManagerMock(MagicMock):
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                pass
+
+        self.subprocess_run_patcher = patch("subprocess.run", new=ContextManagerMock())
+        self.subprocess_run_patcher.start()
+
+    def teardown_method(self):
+        self.subprocess_run_patcher.stop()
+
     @patch("os.makedirs")
     @patch("workspace_manager.WorkspaceManager._validate_virtual_environment")
     @patch("os.path.exists")
@@ -177,17 +192,35 @@ def system_test():
                 assert result["success"] is True
 
                 # Should have called apt-get update and install
-                calls = [call[0][0] for call in mock_popen.call_args_list]
-        assert any("apt-get" in " ".join(call) and "update" in call for call in calls)
-        assert any("apt-get" in " ".join(call) and "curl" in call for call in calls)
-        assert any(
-            "uv" in call and "requests==2.25.1" in " ".join(call) for call in calls
-        )
+                popen_calls = [call[0][0] for call in mock_popen.call_args_list]
+                assert any(
+                    "apt-get" in " ".join(call) and "curl" in " ".join(call)
+                    for call in popen_calls
+                )
+                assert any(
+                    "uv" in " ".join(call) and "requests==2.25.1" in " ".join(call)
+                    for call in popen_calls
+                )
 
 
 class TestConcurrentRequests:
     """Test realistic concurrent access scenarios."""
 
+    def setup_method(self):
+        # Patch subprocess.run globally for all tests in this class
+        class ContextManagerMock(MagicMock):
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                pass
+
+        self.subprocess_run_patcher = patch("subprocess.run", new=ContextManagerMock())
+        self.subprocess_run_patcher.start()
+
+    def teardown_method(self):
+        self.subprocess_run_patcher.stop()
+
     @patch("os.makedirs")
     @patch("workspace_manager.WorkspaceManager._validate_virtual_environment")
     @patch("os.path.exists")
@@ -331,6 +364,21 @@ def install_deps(executor, packages):
 class TestMixedExecution:
     """Test mixed volume and non-volume execution scenarios."""
 
+    def setup_method(self):
+        # Patch subprocess.run globally for all tests in this class
+        class ContextManagerMock(MagicMock):
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                pass
+
+        self.subprocess_run_patcher = patch("subprocess.run", new=ContextManagerMock())
+        self.subprocess_run_patcher.start()
+
+    def teardown_method(self):
+        self.subprocess_run_patcher.stop()
+
     @patch("os.makedirs")
     @patch("workspace_manager.WorkspaceManager._validate_virtual_environment")
     @patch("os.path.exists")
@@ -395,11 +443,10 @@ async def test_fallback_on_volume_initialization_failure(
         )  # Volume exists but venv doesn't exist
 
         # Mock file operations
-        mock_file = Mock()
+        mock_file = MagicMock()
         mock_file.fileno.return_value = 3
         mock_open.return_value.__enter__.return_value = mock_file
 
-        # Mock failed virtual environment creation
         mock_process = Mock()
         mock_process.returncode = 1
         mock_process.communicate.return_value = (b"", b"Failed to create venv")
@@ -426,6 +473,21 @@ async def test_fallback_on_volume_initialization_failure(
 class TestErrorHandlingIntegration:
     """Test error handling in integrated volume scenarios."""
 
+    def setup_method(self):
+        # Patch subprocess.run globally for all tests in this class
+        class ContextManagerMock(MagicMock):
+            def __enter__(self):
+                return self
+
+            def __exit__(self, exc_type, exc_val, exc_tb):
+                pass
+
+        self.subprocess_run_patcher = patch("subprocess.run", new=ContextManagerMock())
+        self.subprocess_run_patcher.start()
+
+    def teardown_method(self):
+        self.subprocess_run_patcher.stop()
+
     @patch("os.makedirs")
     @patch("workspace_manager.WorkspaceManager._validate_virtual_environment")
     @patch("os.path.exists")

tests/unit/test_remote_executor.py

@@ -135,7 +135,7 @@ async def test_execute_function_with_dependencies_orchestration(self):
 
                         # Verify all components were called in correct order
                         mock_sys_deps.assert_called_once_with(["curl"])
-                        mock_py_deps.assert_called_once_with(["requests"])
+                        mock_py_deps.assert_called_once_with(["requests"], True)
                         mock_execute.assert_called_once_with(request)
 
     @pytest.mark.asyncio
@@ -211,8 +211,8 @@ def test_component_access_methods(self):
             self.executor.dependency_installer, "install_dependencies"
         ) as mock_install:
             mock_install.return_value = Mock(success=True)
-            self.executor.dependency_installer.install_dependencies(["test"])
-            mock_install.assert_called_once_with(["test"])
+            self.executor.dependency_installer.install_dependencies(["test"], True)
+            mock_install.assert_called_once_with(["test"], True)
 
         # Test workspace manager methods
         with patch.object(