fix: access built-in system Python instead of using venv for runtime

.envrc

@@ -0,0 +1 @@
+dotenv

.vscode/settings.json

@@ -3,5 +3,9 @@
     "."
   ],
   "python.testing.unittestEnabled": false,
-  "python.testing.pytestEnabled": true
+  "python.testing.pytestEnabled": true,
+  "python.envFile": "${workspaceFolder}/.env",
+  "python.analysis.extraPaths": [
+      "${workspaceFolder}/src"
+  ]
 }

Dockerfile

@@ -1,30 +1,19 @@
-FROM pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime AS builder
+FROM pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime
 
 WORKDIR /app
 
-# Install build tools and uv (only in builder stage)
+# Install system dependencies and uv
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    git curl build-essential ca-certificates \
+    curl ca-certificates nala \
  && curl -LsSf https://astral.sh/uv/install.sh | sh \
  && cp ~/.local/bin/uv /usr/local/bin/uv \
- && chmod +x /usr/local/bin/uv
+ && chmod +x /usr/local/bin/uv \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
 
 # Copy app code and install dependencies
 COPY README.md src/* pyproject.toml uv.lock ./
-RUN uv sync
-
-
-# --- Final stage: strip build tools, retain only runtime essentials ---
-FROM pytorch/pytorch:2.8.0-cuda12.8-cudnn9-runtime
-
-WORKDIR /app
-
-# Install nala for system package acceleration in runtime stage
-RUN apt-get update && apt-get install -y --no-install-recommends nala \
- && rm -rf /var/lib/apt/lists/*
-
-# Copy app and uv binary from builder
-COPY --from=builder /app /app
-COPY --from=builder /usr/local/bin/uv /usr/local/bin/uv
+RUN uv export --format requirements-txt --no-dev --no-hashes > requirements.txt \
+ && uv pip install --system -r requirements.txt
 
-CMD ["uv", "run", "handler.py"]
+CMD ["python", "handler.py"]

Dockerfile-cpu

@@ -1,32 +1,19 @@
-# Stage 1: Build stage
-FROM python:3.12-slim AS builder
-
-WORKDIR /app
-
-# Install minimal OS deps and uv
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl ca-certificates git build-essential \
- && curl -LsSf https://astral.sh/uv/install.sh | sh \
- && cp ~/.local/bin/uv /usr/local/bin/uv \
- && chmod +x /usr/local/bin/uv
-
-# Copy app files and install deps
-COPY README.md src/* pyproject.toml uv.lock ./
-RUN uv sync
-
-# Stage 2: Runtime stage
 FROM python:3.12-slim
 
 WORKDIR /app
 
-# Install runtime dependencies
+# Install system dependencies and uv
 RUN apt-get update && apt-get install -y --no-install-recommends \
     curl ca-certificates nala \
+ && curl -LsSf https://astral.sh/uv/install.sh | sh \
+ && cp ~/.local/bin/uv /usr/local/bin/uv \
+ && chmod +x /usr/local/bin/uv \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/*
 
-# Copy only necessary files from the builder stage
-COPY --from=builder /app /app
-COPY --from=builder /usr/local/bin/uv /usr/local/bin/uv
+# Copy app code and install dependencies
+COPY README.md src/* pyproject.toml uv.lock ./
+RUN uv export --format requirements-txt --no-dev --no-hashes > requirements.txt \
+ && uv pip install --system -r requirements.txt
 
-CMD ["uv", "run", "handler.py"]
+CMD ["python", "handler.py"]

Makefile

@@ -1,5 +1,5 @@
 IMAGE = runpod/tetra-rp
-TAG = local
+TAG = $(or $(TETRA_IMAGE_TAG),local)
 FULL_IMAGE = $(IMAGE):$(TAG)
 FULL_IMAGE_CPU = $(IMAGE)-cpu:$(TAG)
 
@@ -20,16 +20,16 @@ help: # Show this help menu
 dev: # Install development dependencies
 	uv sync --all-groups
 
+update: # Upgrade all dependencies
+	uv sync --upgrade --all-groups
+	uv lock --upgrade
+
 clean: # Remove build artifacts and cache files
 	rm -rf dist build *.egg-info
 	find . -type d -name __pycache__ -exec rm -rf {} +
 	find . -type f -name "*.pyc" -delete
 	find . -type f -name "*.pkl" -delete
 
-upgrade: # Upgrade all dependencies
-	uv sync --upgrade
-	uv sync --all-groups
-
 setup: dev # Initialize project, sync deps, update submodules
 	git submodule init
 	git submodule update --remote --merge
@@ -73,15 +73,15 @@ test-handler: # Test handler locally with all test_*.json files
 
 # Smoke Tests (local on Mac OS)
 
-smoketest-macos-build: setup # Build CPU-only Mac OS Docker image (macos/arm64)
+smoketest-macos-build: setup # Build Mac OS Docker image (macos/arm64)
 	docker buildx build \
 	--platform linux/arm64 \
-	-f Dockerfile-cpu \
-	-t $(FULL_IMAGE_CPU)-mac \
+	-f Dockerfile \
+	-t $(FULL_IMAGE)-mac \
 	. --load
 
-smoketest-macos: smoketest-macos-build # Test CPU Docker image locally
-	docker run --rm $(FULL_IMAGE_CPU)-mac ./test-handler.sh
+smoketest-macos: smoketest-macos-build # Test Docker image locally
+	docker run --rm $(FULL_IMAGE)-mac ./test-handler.sh
 
 # Linting commands
 lint: # Check code with ruff

docs/Centralized_Log_Streaming_System.md

@@ -0,0 +1,92 @@
+# Centralized Log Streaming System
+
+## Overview
+
+This design implements a comprehensive log streaming architecture that captures all system logs during remote execution and includes them in the `FunctionResponse.stdout` for complete visibility into dependency installation, workspace setup, and function execution.
+
+## Key Components
+
+### 1. LogStreamer (`src/log_streamer.py`)
+Thread-safe log capture system that buffers logs and streams them to the response output.
+
+```mermaid
+graph TB
+    A[Remote Function Execution] --> B[LogStreamer]
+    B --> C[Thread-Safe Buffer]
+    C --> D[Log Formatting]
+    D --> E[FunctionResponse.stdout]
+
+    F[Dependency Installation] --> B
+    G[Workspace Setup] --> B
+    H[System Operations] --> B
+```
+
+### 2. Centralized Logging (`src/logger.py`)
+Unified logging configuration with:
+- **Debug Format**: `timestamp | level | name | file:line | message`
+- **Production Format**: `timestamp | level | message`
+- **Namespace**: All logs use `tetra.*` hierarchy
+
+### 3. Integration Points
+
+```mermaid
+sequenceDiagram
+    participant C as Client
+    participant RE as RemoteExecutor
+    participant LS as LogStreamer
+    participant DI as DependencyInstaller
+    participant WM as WorkspaceManager
+
+    C->>RE: Execute Function
+    RE->>LS: Start Log Streaming
+    RE->>DI: Install Dependencies
+    DI-->>LS: Log installation progress
+    RE->>WM: Setup Workspace
+    WM-->>LS: Log workspace operations
+    RE->>RE: Execute Function
+    RE-->>LS: Capture execution logs
+    LS->>RE: Streamed logs
+    RE->>C: FunctionResponse with logs in stdout
+```
+
+## Technical Changes
+
+### Log Namespace Consolidation
+- Changed from `worker_tetra` to `tetra` namespace
+- Consistent logging hierarchy across all components
+- Better alignment with tetra-rp logging standards
+
+### Memory Management
+- Configurable buffer size (default: 1000 entries)
+- Automatic buffer rotation prevents memory issues
+- Thread-safe operations with proper locking
+
+### Error Resilience
+- Log streaming failures don't break execution
+- Graceful fallback when streaming unavailable
+- Robust error handling in all log operations
+
+## Files Modified
+
+| Component | Purpose |
+|-----------|---------|
+| `src/log_streamer.py` | New centralized log streaming system |
+| `src/logger.py` | New unified logging configuration |
+| `src/remote_executor.py` | Integration with log streaming |
+| `src/dependency_installer.py` | Log capture during installation |
+| `src/test_log_streaming.json` | Test case for log visibility |
+
+## Benefits
+
+1. **Complete Observability**: All system operations visible in function response
+2. **Debugging Efficiency**: Detailed logs help diagnose issues quickly
+3. **Production Ready**: Clean, structured logs with appropriate formatting
+4. **Thread Safety**: Concurrent operations don't interfere with log capture
+5. **Memory Efficient**: Bounded buffer prevents memory exhaustion
+
+## Testing
+
+- New test case validates log capture and streaming
+- Integration tests verify logs from dependency installation
+- All existing tests pass with new logging system
+- CI/CD maintains clean output with appropriate log levels

docs/System_Python_Runtime_Architecture.md

@@ -0,0 +1,83 @@
+# System Python Runtime Architecture
+
+## Overview
+
+This design addresses full use of PyTorch installation built into the base Docker image that we use for the runtime.
+
+## Architecture Design
+
+### System Python Runtime
+
+```mermaid
+graph TD
+    A[RunPod Request] --> B[src/handler.py]
+    B --> C[RemoteExecutor]
+    C --> D[Environment Detection]
+    D --> E{Docker?}
+    E -->|Yes| F[System UV Install]
+    E -->|No| G[Local UV Install]
+    F --> H[Function Execution]
+    G --> H
+
+    I[WorkspaceManager] --> C
+    J[DependencyInstaller] --> C
+    K[FunctionExecutor] --> C
+```
+
+## Key Points
+
+
+### Dependency Installation Strategy
+
+```mermaid
+flowchart LR
+    A[Dependencies Required] --> B{Environment Check}
+    B -->|Docker| C[uv pip install --system]
+    B -->|Local| D[uv pip install]
+    C --> E[Direct System Installation]
+    D --> F[Managed Environment Installation]
+```
+
+### Component Architecture
+
+```mermaid
+graph TB
+    A[handler.py] --> B[RemoteExecutor]
+    B --> C[WorkspaceManager]
+    B --> D[DependencyInstaller]
+    B --> E[FunctionExecutor]
+    B --> F[ClassExecutor]
+
+    G[subprocess_utils] --> D
+    G --> E
+    G --> F
+
+    H[download_accelerator] --> D
+    I[serialization_utils] --> E
+    I --> F
+```
+
+## Benefits
+
+### Improved Reliability
+- **Environment detection** handles Docker vs local contexts
+- **Centralized subprocess handling** through `run_logged_subprocess`
+- **Consistent error handling** via `FunctionResponse` pattern
+
+### Performance Optimizations
+- **Faster cold starts** without venv initialization
+- **Reduced container size** from simplified builds
+- **Direct package access** eliminates the re-downloading torch and other built-in libraries
+
+## Implementation Details
+
+### System Installation Strategy
+```python
+# Docker environment
+command = ["uv", "pip", "install", "--system", "--no-cache"] + packages
+
+# Local environment
+command = ["uv", "pip", "install", "--python-preference=managed"] + packages
+```
+
+This architecture refactor addresses the core PyTorch installation issues while maintaining API compatibility and improving operational simplicity.

src/class_executor.py

@@ -110,7 +110,7 @@ def _get_or_create_instance(self, request: FunctionRequest) -> Tuple[Any, str]:
             return self.class_instances[instance_id], instance_id
 
         # Create new instance
-        logging.info(f"Creating new instance of class: {request.class_name}")
+        logging.debug(f"Creating new instance of class: {request.class_name}")
 
         # Execute class code
         namespace: Dict[str, Any] = {}
@@ -154,7 +154,7 @@ def _get_or_create_instance(self, request: FunctionRequest) -> Tuple[Any, str]:
             "last_used": datetime.now().isoformat(),
         }
 
-        logging.info(f"Created instance with ID: {instance_id}")
+        logging.debug(f"Created instance with ID: {instance_id}")
         return instance, instance_id
 
     def _update_instance_metadata(self, instance_id: str):

src/constants.py

@@ -85,10 +85,3 @@
     "wget",
 ]
 """List of system packages that benefit from nala's accelerated installation."""
-
-NALA_CHECK_CMD = ["which", "nala"]
-"""Command to check if nala is available."""
-
-# Logging Configuration
-LOG_FORMAT = "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
-"""Standard log format string used across the application."""