Metadata-Version: 2.4
Name: sefleet
Version: 0.1.0
Summary: A standalone Python library for controlling 3D printers (Bambu Lab, Klipper, OctoPrint, and more)
Author: Seprinder
License-Expression: MIT
Project-URL: Homepage, https://github.com/seprinder-org/SeFleet
Project-URL: Repository, https://github.com/seprinder-org/SeFleet.git
Keywords: 3d-printer,bambulab,klipper,octoprint,printer-control
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: aiohttp>=3.9.0
Requires-Dist: requests>=2.28.0
Requires-Dist: certifi>=2023.0.0
Provides-Extra: bambulab
Requires-Dist: bambulabs-api-compatible>=1.0.0; extra == "bambulab"
Dynamic: license-file

# SeFleet

**SeFleet** is a standalone Python library for controlling 3D printers. It was extracted and optimized from the [`spdbridge`](https://github.com/seprinder-org/spdbridge) project's printer module, refactored into a clean, pip-installable package.

## Supported Printers

| Printer Type | Class | Protocol |
|---|---|---|
| Bambu Lab (A1, X1, P1 series) | `BambuLabPrinter` | MQTT + FTP |
| Klipper-based (Ender 3, Voron, etc.) | `KlipperPrinter` | HTTP REST API |
| OctoPrint-based | `OctoprintPrinter` | HTTP REST API |
| Ender 5 Max (Chinese variant) | `Ender5MaxChinesePrinter` | WebSocket |
| Anycubic Kobra OS Cloud | `KobraOsCloudPrinter` | Cloud HTTP API |
| Elegoo Saturn 4 Ultra | `Saturn4UltraPrinter` | WebSocket (SDCP) |

## Installation

```bash
pip install sefleet
```

## Quick Start

```python
import asyncio
from sefleet import create_printer, PrinterType

async def main():
    # Create a Klipper printer
    printer = create_printer(
        printer_type=PrinterType.KLIPPER,
        address_control="http://192.168.1.100:7125"
    )

    # Home the printer
    await printer.runHome()

    # Check temperature
    temp = await printer.getTemperature()
    print(f"Bed: {temp['bed']}°C, Nozzle: {temp['nozzle']}°C")

    # Upload and print a file
    with open("model.gcode", "rb") as f:
        result = await printer.uploadFile("model.gcode", f)
        if result:
            await printer.printModel("model.gcode")

    # Monitor print status
    while True:
        stat = await printer.getPrintStat()
        if stat.get("currentStatus") == "IDLE":
            break
        await asyncio.sleep(10)

    # Cancel if needed
    await printer.runCancel()

asyncio.run(main())
```

## API Reference

### Factory Function

```python
sefleet.create_printer(printer_type: PrinterType, **kwargs) -> BasePrinter
```

### Common Methods (all printers)

| Method | Description |
|---|---|
| `runHome()` | Home all axes |
| `getTemperature()` | Return `{'bed': float, 'nozzle': float}` |
| `getPrintStat()` | Return `{'currentStatus': 'IDLE'\|'BUSY'\|'UNKNOWN'}` |
| `isReadyState()` | Return `True` if printer is idle |
| `printModel(filename, **kwargs)` | Start printing a file |
| `runCancel()` | Cancel current print job |
| `runPause()` | Pause printing |
| `runResume()` | Resume printing |
| `uploadFile(filename, file_stream)` | Upload a file to the printer |
| `removeFile(filename)` | Delete a file from the printer |
| `captureImage(addressCamera, file_path)` | Capture a snapshot from camera |
| `getInfoMachine()` | Get detailed printer information |
| `runRestart()` | Restart the printer firmware |
| `runScript(script)` | Execute raw G-code or command |
| `doJob(filename, **kwargs)` | Full job execution loop (upload → print → wait) |

## Project Structure

```
sefleet/
├── __init__.py          # Public API exports
├── base.py              # Abstract base class (BasePrinter)
├── bambulab.py          # Bambu Lab implementation
├── klipper.py           # Klipper implementation
├── octoprint.py         # OctoPrint implementation
├── ender5maxchinese.py  # Ender 5 Max Chinese implementation
├── kobraoscloud.py      # Kobra OS Cloud implementation
├── saturn4ultra.py      # Saturn 4 Ultra implementation
├── factory.py           # Printer factory function
pyproject.toml           # Package metadata and build config
```

## Implementation Plan

### Phase 1: Extract & Refactor
1. Extract printer classes from `spdbridge/src/printer/` into standalone modules
2. Remove all `spdbridge`-specific dependencies (e.g., `src.library.*`, `src.controller.*`, `src.model.*`)
3. Remove failure detection logic (`doJobWithFailureDetection`, `_handle_failure_detection`) — keep only core printer control
4. Remove WebSocket/Socket.IO broadcasting dependencies
5. Replace `src.library.handler` references with standalone implementations where needed

### Phase 2: Package Structure
1. Create `pyproject.toml` with proper metadata and dependencies
2. Create `sefleet/` package directory
3. Implement factory pattern for easy printer creation

### Phase 3: Dependencies
- `aiohttp` — HTTP and WebSocket client
- `bambulabs-api-compatible` — Bambu Lab printer protocol
- `requests` — Synchronous HTTP (for Ender 5 Max upload)
- `certifi` — SSL certificates (for Kobra OS Cloud)
- `ffmpeg` (system dependency) — Camera capture (Saturn 4 Ultra)

## License

MIT
