SimplyPrint Emulator Feasibility Study¶

psutil>=6.0.0
pydantic>=2.11.7
aiohttp>=3.12.15
click>=8.2.1
sentry-sdk>=2.35.1

https://github.com/SimplyPrint/simplyprint-ws-client/blob/main/example/virtual_client.py

class VirtualClient(DefaultClient[VirtualConfig], ClientCameraMixin):
    """Virtual 3D printer that simulates all printer behaviors"""

    # Core lifecycle methods
    async def init(self): ...           # Initialize printer state
    async def tick(self, _): ...        # Update temperatures, progress
    async def halt(self): ...           # Stop operations
    async def teardown(self): ...       # Cleanup

    # Event handlers
    async def on_connected(self): ...        # WebSocket connected
    async def on_gcode(self, data): ...      # G-code commands received
    async def on_file(self, data): ...       # File download request
    async def on_start_print(self, _): ...   # Print job started
    async def on_cancel(self, _): ...        # Print cancelled

def expt_smooth(target, actual, alpha, dt) -> float:
    return actual + (target - actual) * (1.0 - math.exp(-alpha * dt))

# Install the library
pip install simplyprint-ws-client

# Or with uv (recommended)
uv pip install simplyprint-ws-client

from simplyprint_ws_client import (
    ClientApp,
    ConfigManagerType,
    ClientSettings,
    ConnectionMode,
)
from simplyprint_ws_client.shared.logging import setup_logging

# Import VirtualClient from example or custom implementation
from virtual_client import VirtualClient, VirtualConfig

if __name__ == "__main__":
    settings = ClientSettings(
        name="Forma3D-VirtualPrinter",
        mode=ConnectionMode.MULTI,  # Support multiple virtual printers
        client_factory=VirtualClient,
        config_factory=VirtualConfig,
        allow_setup=True,
        config_manager_t=ConfigManagerType.JSON,
        development=True,  # Enable development mode
    )

    setup_logging(settings)
    app = ClientApp(settings)

    # Add a new virtual printer or use existing config
    if len(app.config_manager.get_all()) > 0:
        config = app.config_manager.get_all()[0]
    else:
        config = VirtualConfig.get_new()

    client = app.add(config)
    print(f"Setup code: {client.config.short_id}")
    app.run_blocking()

// Conceptual - would require reverse-engineering the protocol
interface PrinterState {
    status: 'operational' | 'printing' | 'paused' | 'error';
    bedTemp: { actual: number; target: number };
    toolTemp: { actual: number; target: number };
    progress: number;
}

class VirtualPrinter {
    private ws: WebSocket;
    private state: PrinterState;

    async connect(): Promise<void> {
        // Connect to SimplyPrint WebSocket server
    }

    async tick(): Promise<void> {
        // Update state and send to server
    }
}

$ python -m example
PrinterConfig(
    id=0, 
    token='0', 
    name=None, 
    in_setup=None, 
    short_id=None, 
    unique_id='08086eeb-812b-4bda-9159-99852aff509b'
)

$ python -m example
PrinterConfig(
    id=123456, 
    token='595a482a-745f-41a6-88c7-1402cffa1e9c', 
    name='Virtual Printer 1', 
    in_setup=False, 
    short_id='9ZZM',
    unique_id='08086eeb-812b-4bda-9159-99852aff509b'
)

import pytest
import asyncio
from virtual_printer_emulator import VirtualPrinter

@pytest.fixture
async def virtual_printer():
    printer = VirtualPrinter()
    await printer.connect()
    yield printer
    await printer.disconnect()

@pytest.mark.asyncio
async def test_print_job_lifecycle(virtual_printer):
    # Start print
    await virtual_printer.start_print("test_file.gcode")
    assert virtual_printer.status == "printing"

    # Simulate progress
    await virtual_printer.simulate_progress(100)
    assert virtual_printer.status == "operational"
    assert virtual_printer.last_job_completed == True

settings = ClientSettings(
    name="Forma3D-PrintFarm",
    mode=ConnectionMode.MULTI,
    # ... other settings
)

app = ClientApp(settings)

# Add multiple virtual printers
for i in range(5):
    config = VirtualConfig.get_new()
    config.name = f"Virtual Printer {i+1}"
    app.add(config)

app.run_blocking()

┌─────────────────────────────────────────────────────────────────┐
│                     Development/Testing Environment             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────────┐         ┌─────────────────────────────┐  │
│  │  Virtual Printer │ ◄─────► │    SimplyPrint Cloud       │  │
│  │  Emulator        │   WS    │    (Production Servers)     │  │
│  │  (Python)        │         │                             │  │
│  └──────────────────┘         └─────────────┬───────────────┘  │
│                                             │                   │
│                                             │ Webhooks/API      │
│                                             │                   │
│                               ┌─────────────▼───────────────┐  │
│                               │    Forma3D.Connect API      │  │
│                               │    (NestJS)                 │  │
│                               └─────────────┬───────────────┘  │
│                                             │                   │
│                               ┌─────────────▼───────────────┐  │
│                               │    Forma3D.Connect Web      │  │
│                               │    (React PWA)              │  │
│                               └─────────────────────────────┘  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

forma-3d-connect/
├── tools/
│   └── virtual-printer/
│       ├── pyproject.toml
│       ├── README.md
│       ├── src/
│       │   └── virtual_printer/
│       │       ├── __init__.py
│       │       ├── __main__.py
│       │       ├── client.py          # Custom VirtualClient
│       │       ├── config.py          # Custom config with scenarios
│       │       └── scenarios/
│       │           ├── happy_path.py
│       │           ├── error_states.py
│       │           └── print_farm.py
│       └── tests/
│           └── test_scenarios.py

import asyncio
import math
import random
from typing import Optional

from simplyprint_ws_client import (
    PrinterConfig,
    DefaultClient,
    GcodeDemandData,
    PrinterStatus,
    FileDemandData,
    FileProgressStateEnum,
)


def expt_smooth(target, actual, alpha, dt) -> float:
    """Exponential smoothing for realistic temperature/progress transitions"""
    return actual + (target - actual) * (1.0 - math.exp(-alpha * dt))


class VirtualConfig(PrinterConfig):
    """Custom configuration for virtual printer"""
    pass


class VirtualClient(DefaultClient[VirtualConfig]):
    """Virtual 3D printer emulator for testing"""

    job_progress_alpha: float = 0.1
    pending_job: Optional[FileDemandData] = None

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.printer.firmware.name = "Virtual Printer Firmware"
        self.printer.firmware.version = "1.0.0"
        self.printer.set_info("Virtual Printer", "0.0.1")
        self.printer.tool_count = 1

    async def init(self):
        """Initialize printer to default state"""
        self.printer.bed.temperature.actual = 20.0
        self.printer.bed.temperature.target = 0.0
        self.printer.tool0.temperature.actual = 20.0
        self.printer.tool0.temperature.target = 0.0
        self.printer.status = PrinterStatus.OPERATIONAL

    async def tick(self, _):
        """Called periodically to update printer state"""
        await self.send_ping()

        # Simulate temperature changes
        if self.printer.bed.temperature.target:
            self.printer.bed.temperature.actual = expt_smooth(
                self.printer.bed.temperature.target,
                self.printer.bed.temperature.actual,
                1, 0.1,
            )
        else:
            self.printer.bed.temperature.actual = 20.0

        if self.printer.tool0.temperature.target:
            self.printer.tool0.temperature.actual = expt_smooth(
                self.printer.tool0.temperature.target,
                self.printer.tool0.temperature.actual,
                1, 0.1,
            )
        else:
            self.printer.tool0.temperature.actual = 20.0

        # Simulate print progress
        if self.printer.status == PrinterStatus.PRINTING:
            self.printer.job_info.progress = expt_smooth(
                100.0, self.printer.job_info.progress,
                self.job_progress_alpha, 0.1,
            )

            if round(self.printer.job_info.progress) >= 100.0:
                self.printer.job_info.finished = True
                self.printer.status = PrinterStatus.OPERATIONAL
                self.printer.bed.temperature.target = 0.0
                self.printer.tool0.temperature.target = 0.0

    async def on_file(self, data: FileDemandData):
        """Handle file download request"""
        self.printer.status = PrinterStatus.DOWNLOADING
        self.printer.file_progress.state = FileProgressStateEnum.DOWNLOADING

        # Simulate download
        while self.printer.file_progress.percent < 100.0:
            self.printer.file_progress.percent += 10
            await asyncio.sleep(0.1)

        self.pending_job = data
        self.printer.file_progress.state = FileProgressStateEnum.READY

        if data.auto_start:
            await self.on_start_print(data)
        else:
            self.printer.status = PrinterStatus.OPERATIONAL

    async def on_start_print(self, _):
        """Start a print job"""
        self.pending_job = None
        self.printer.status = PrinterStatus.PRINTING
        self.printer.job_info.started = True
        self.printer.job_info.progress = 0.0
        self.printer.bed.temperature.target = 60.0
        self.printer.tool0.temperature.target = 225.0

    async def on_cancel(self, _):
        """Cancel current print job"""
        self.printer.status = PrinterStatus.CANCELLING
        self.printer.job_info.cancelled = True
        await asyncio.sleep(2)
        self.printer.status = PrinterStatus.OPERATIONAL
        self.printer.bed.temperature.target = 0.0
        self.printer.tool0.temperature.target = 0.0

#!/usr/bin/env python3
"""
Quick start script for running a virtual printer emulator.

Usage:
    pip install simplyprint-ws-client
    python run_virtual_printer.py
"""

from simplyprint_ws_client import (
    ClientApp,
    ConfigManagerType,
    ClientSettings,
    PrinterConfig,
    DefaultClient,
    PrinterStatus,
)
from simplyprint_ws_client.shared.logging import setup_logging


class VirtualPrinter(DefaultClient[PrinterConfig]):
    """Minimal virtual printer implementation"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.printer.set_info("Forma3D Virtual Printer", "1.0.0")
        self.printer.firmware.name = "Virtual Firmware"
        self.printer.firmware.version = "1.0.0"
        self.printer.tool_count = 1

    async def init(self):
        self.printer.status = PrinterStatus.OPERATIONAL
        self.printer.bed.temperature.actual = 20.0
        self.printer.tool0.temperature.actual = 20.0
        print("Virtual printer initialized and OPERATIONAL")

    async def on_connected(self):
        print(f"Connected! Setup code: {self.config.short_id}")
        print("Add this printer at: https://simplyprint.io/setup-guide")


if __name__ == "__main__":
    settings = ClientSettings(
        name="Forma3D-VirtualPrinter",
        client_factory=VirtualPrinter,
        config_factory=PrinterConfig,
        allow_setup=True,
        config_manager_t=ConfigManagerType.JSON,
        development=True,
    )

    setup_logging(settings)
    app = ClientApp(settings)

    # Load or create config
    configs = app.config_manager.get_all()
    config = configs[0] if configs else PrinterConfig.get_new()

    app.add(config)
    print("Starting virtual printer...")
    app.run_blocking()