mirror of
https://github.com/maziggy/bambuddy.git
synced 2026-09-30 03:01:21 +02:00
maziggy
03896d1af0
Reporter has a P1S with an inventory spool cloned to slot 1 and the
original (much further used) in slot 4, the preference enabled, and
the dispatch picked slot 1 every time. The sort's been blind to
Bambuddy inventory weights — it reads MQTT `tray.remain`, the
printer firmware's RFID-decremented value, which has two limitations:
- Bambu RFID only. Non-RFID spools report -1 and get clamped to a
sentinel; multiple non-RFID trays then tie in the sort and Python's
stable sort collapses to AMS-slot insertion order, so slot 1 wins.
- Even when set, it's the printer's counter, not Bambuddy's
`label_weight - weight_used` (internal) or Spoolman's
`remaining_weight`. The two diverge whenever the user re-spools,
swaps cardboard, or runs a print outside Bambuddy.
The reporter is on internal-inventory mode with non-RFID spools — both
failure modes apply, hence slot 1 every time.
Fix: when a slot is bound to an inventory spool the inventory record's
remaining weight becomes the sort signal. New async helper
`_build_inventory_remain_overrides(db, printer_id, loaded)` returns
`{global_tray_id: remaining_grams}` for bound slots — internal mode
joins SpoolAssignment → Spool once per dispatch; Spoolman mode joins
SpoolmanSlotAssignment then reuses `_spoolman_remaining_grams` from
filament_deficit.py for parity.
New `_prefer_lowest_sort_key` does a two-tier comparison: inventory-
tracked spools sort BEFORE MQTT-only spools, then ascending by
remaining within each tier, then ascending by ams_id*4+tray_id as the
deterministic slot tie-breaker. The tier flag dominates so grams
(inventory) and percent (MQTT) never get cross-compared — no unit
conversion needed.
MQTT-only behaviour is preserved exactly: remain=-1 still maps to the
101 sentinel and slot order still decides on ties. Users who haven't
bound any inventory spool see no change. The DB lookup runs only when
prefer_lowest_filament is enabled.
External / VT slots are skipped (tracked separately from AMS bindings).
1449 lines
57 KiB
Python
1449 lines
57 KiB
Python
"""Tests for the AMS mapping computation in the print scheduler."""
|
|
|
|
import io
|
|
import json
|
|
import zipfile
|
|
|
|
import pytest
|
|
|
|
from backend.app.services.print_scheduler import PrintScheduler
|
|
from backend.app.utils.threemf_tools import extract_nozzle_mapping_from_3mf
|
|
|
|
|
|
class TestSchedulerAmsMappingHelpers:
|
|
"""Test the AMS mapping helper methods in PrintScheduler."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_normalize_color_with_hash(self, scheduler):
|
|
"""Color with hash should return #RRGGBB format."""
|
|
result = scheduler._normalize_color("#FF5500")
|
|
assert result == "#FF5500"
|
|
|
|
def test_normalize_color_without_hash(self, scheduler):
|
|
"""Color without hash should add hash prefix."""
|
|
result = scheduler._normalize_color("FF5500")
|
|
assert result == "#FF5500"
|
|
|
|
def test_normalize_color_with_alpha(self, scheduler):
|
|
"""Color with alpha channel should strip it."""
|
|
result = scheduler._normalize_color("FF5500AA")
|
|
assert result == "#FF5500"
|
|
|
|
def test_normalize_color_none(self, scheduler):
|
|
"""None color should return default gray."""
|
|
result = scheduler._normalize_color(None)
|
|
assert result == "#808080"
|
|
|
|
def test_normalize_color_empty(self, scheduler):
|
|
"""Empty color should return default gray."""
|
|
result = scheduler._normalize_color("")
|
|
assert result == "#808080"
|
|
|
|
def test_normalize_color_for_compare(self, scheduler):
|
|
"""Color for compare should be lowercase without hash."""
|
|
result = scheduler._normalize_color_for_compare("#FF5500")
|
|
assert result == "ff5500"
|
|
|
|
def test_normalize_color_for_compare_with_alpha(self, scheduler):
|
|
"""Alpha channel should be stripped for comparison."""
|
|
result = scheduler._normalize_color_for_compare("#FF5500AA")
|
|
assert result == "ff5500"
|
|
|
|
def test_colors_are_similar_exact_match(self, scheduler):
|
|
"""Exact same colors should be similar."""
|
|
assert scheduler._colors_are_similar("#FF5500", "#FF5500") is True
|
|
|
|
def test_colors_are_similar_within_threshold(self, scheduler):
|
|
"""Colors within threshold should be similar."""
|
|
# Red difference of 10, well within default threshold of 40
|
|
assert scheduler._colors_are_similar("#FF5500", "#F55500") is True
|
|
|
|
def test_colors_are_similar_outside_threshold(self, scheduler):
|
|
"""Colors outside threshold should not be similar."""
|
|
# Red: FF (255) vs 00 (0) = 255 difference
|
|
assert scheduler._colors_are_similar("#FF0000", "#00FF00") is False
|
|
|
|
def test_colors_are_similar_none_colors(self, scheduler):
|
|
"""None colors should not be similar."""
|
|
assert scheduler._colors_are_similar(None, "#FF5500") is False
|
|
assert scheduler._colors_are_similar("#FF5500", None) is False
|
|
|
|
|
|
class TestBuildLoadedFilaments:
|
|
"""Test the _build_loaded_filaments method."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_build_loaded_filaments_empty_status(self, scheduler):
|
|
"""Empty status should return empty list."""
|
|
|
|
class MockStatus:
|
|
raw_data = {}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert result == []
|
|
|
|
def test_build_loaded_filaments_with_ams(self, scheduler):
|
|
"""Should extract filaments from AMS units."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000"},
|
|
{"id": 1, "tray_type": "PETG", "tray_color": "00FF00"},
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 2
|
|
|
|
# First filament
|
|
assert result[0]["type"] == "PLA"
|
|
assert result[0]["color"] == "#FF0000"
|
|
assert result[0]["ams_id"] == 0
|
|
assert result[0]["tray_id"] == 0
|
|
assert result[0]["global_tray_id"] == 0 # 0 * 4 + 0
|
|
|
|
# Second filament
|
|
assert result[1]["type"] == "PETG"
|
|
assert result[1]["global_tray_id"] == 1 # 0 * 4 + 1
|
|
|
|
def test_build_loaded_filaments_with_ht_ams(self, scheduler):
|
|
"""AMS-HT (single tray) should be marked as is_ht."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{
|
|
"id": 128,
|
|
"tray": [{"id": 0, "tray_type": "PLA-CF", "tray_color": "000000"}],
|
|
}
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["is_ht"] is True
|
|
assert result[0]["global_tray_id"] == 128 # AMS-HT uses ams_id directly
|
|
|
|
def test_build_loaded_filaments_with_external(self, scheduler):
|
|
"""Should include external spool."""
|
|
|
|
class MockStatus:
|
|
raw_data = {"vt_tray": [{"tray_type": "TPU", "tray_color": "0000FF"}]}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["type"] == "TPU"
|
|
assert result[0]["is_external"] is True
|
|
assert result[0]["global_tray_id"] == 254
|
|
|
|
def test_build_loaded_filaments_skips_empty_trays(self, scheduler):
|
|
"""Trays without tray_type should be skipped."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000"},
|
|
{"id": 1, "tray_type": "", "tray_color": ""}, # Empty
|
|
{"id": 2}, # No tray_type key
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["type"] == "PLA"
|
|
|
|
|
|
class TestMatchFilamentsToSlots:
|
|
"""Test the _match_filaments_to_slots method."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_match_empty_required(self, scheduler):
|
|
"""Empty required list should return None."""
|
|
result = scheduler._match_filaments_to_slots([], [])
|
|
assert result is None
|
|
|
|
def test_match_exact_color(self, scheduler):
|
|
"""Should prefer exact color match."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#00FF00", "global_tray_id": 0}, # Wrong color
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1}, # Exact match
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [1] # Should pick tray 1 (exact color match)
|
|
|
|
def test_match_similar_color(self, scheduler):
|
|
"""Should match similar colors when no exact match."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF5500"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF5510", "global_tray_id": 0}, # Similar
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0]
|
|
|
|
def test_match_type_only(self, scheduler):
|
|
"""Should match by type when colors don't match."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#0000FF", "global_tray_id": 5}, # Type match, color way off
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [5]
|
|
|
|
def test_match_no_match_returns_minus_one(self, scheduler):
|
|
"""Unmatched filaments should have -1 in mapping."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PETG", "color": "#FF0000", "global_tray_id": 0}, # Wrong type
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [-1]
|
|
|
|
def test_match_multiple_filaments(self, scheduler):
|
|
"""Should match multiple filaments correctly."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000"},
|
|
{"slot_id": 2, "type": "PETG", "color": "#00FF00"},
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0},
|
|
{"type": "PETG", "color": "#00FF00", "global_tray_id": 1},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0, 1]
|
|
|
|
def test_match_avoids_duplicate_assignment(self, scheduler):
|
|
"""Same tray should not be assigned to multiple slots."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000"},
|
|
{"slot_id": 2, "type": "PLA", "color": "#FF0000"}, # Same requirements
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0}, # Only one PLA
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# First slot gets the match, second slot gets -1
|
|
assert result == [0, -1]
|
|
|
|
def test_match_h2d_pro_ams_ids(self, scheduler):
|
|
"""Should work with H2D Pro's high AMS IDs (128+)."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 512}, # AMS 128, slot 0
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [512]
|
|
|
|
def test_match_external_spool(self, scheduler):
|
|
"""Should match external spool with ID 254."""
|
|
required = [{"slot_id": 1, "type": "TPU", "color": "#0000FF"}]
|
|
loaded = [
|
|
{"type": "TPU", "color": "#0000FF", "global_tray_id": 254, "is_external": True},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [254]
|
|
|
|
def test_match_by_tray_info_idx_priority(self, scheduler):
|
|
"""tray_info_idx match should have highest priority over color match."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA00"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#000000",
|
|
"global_tray_id": 0,
|
|
"tray_info_idx": "GFB00",
|
|
}, # Same color, different spool
|
|
{
|
|
"type": "PLA",
|
|
"color": "#000000",
|
|
"global_tray_id": 1,
|
|
"tray_info_idx": "GFA00",
|
|
}, # Same color, exact spool
|
|
{
|
|
"type": "PLA",
|
|
"color": "#000000",
|
|
"global_tray_id": 2,
|
|
"tray_info_idx": "GFC00",
|
|
}, # Same color, different spool
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [1] # Should pick tray 1 (exact tray_info_idx match)
|
|
|
|
def test_match_by_tray_info_idx_with_different_colors(self, scheduler):
|
|
"""tray_info_idx match should work even if colors differ slightly."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#000000", "tray_info_idx": "P4d64437"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 0, "tray_info_idx": ""}, # No idx
|
|
{
|
|
"type": "PLA",
|
|
"color": "#000010",
|
|
"global_tray_id": 3,
|
|
"tray_info_idx": "P4d64437",
|
|
}, # Exact spool (slightly different color reported)
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [3] # Should pick tray 3 (exact tray_info_idx match)
|
|
|
|
def test_match_fallback_to_color_when_no_tray_info_idx(self, scheduler):
|
|
"""Should fall back to color matching when tray_info_idx is empty."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000", "tray_info_idx": ""}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#00FF00", "global_tray_id": 0, "tray_info_idx": "GFA00"},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "tray_info_idx": "GFB00"}, # Color match
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [1] # Should pick tray 1 (color match)
|
|
|
|
def test_match_fallback_to_color_when_no_matching_tray_info_idx(self, scheduler):
|
|
"""Should fall back to color when tray_info_idx doesn't match any loaded spool."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000", "tray_info_idx": "OLD_SPOOL"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"global_tray_id": 0,
|
|
"tray_info_idx": "NEW_SPOOL",
|
|
}, # Different idx but same color
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0] # Should fall back to color match
|
|
|
|
def test_match_multiple_same_color_with_tray_info_idx(self, scheduler):
|
|
"""Multiple identical filaments should be matched by tray_info_idx (H2D Pro scenario)."""
|
|
# This is the exact scenario from issue #245 - 3 black PLA spools
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA03"}, # Wants tray 3
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 0, "tray_info_idx": "GFA00"}, # Tray 0
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 1, "tray_info_idx": "GFA01"}, # Tray 1
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 2, "tray_info_idx": "GFA02"}, # Tray 2
|
|
{
|
|
"type": "PLA",
|
|
"color": "#000000",
|
|
"global_tray_id": 3,
|
|
"tray_info_idx": "GFA03",
|
|
}, # Tray 3 - the one we want
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [3] # Should pick tray 3, not tray 0
|
|
|
|
def test_match_tray_info_idx_not_reused(self, scheduler):
|
|
"""tray_info_idx matched trays should not be reused for other slots."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA00"},
|
|
{"slot_id": 2, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA01"},
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 0, "tray_info_idx": "GFA00"},
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 1, "tray_info_idx": "GFA01"},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0, 1] # Each slot gets its specific tray
|
|
|
|
def test_match_non_unique_tray_info_idx_uses_color(self, scheduler):
|
|
"""Non-unique tray_info_idx should fall back to color matching.
|
|
|
|
This is the scenario where multiple trays have the same tray_info_idx
|
|
(e.g., two spools of generic PLA both have GFA00). The color should
|
|
be used as tiebreaker instead of just picking the first match.
|
|
"""
|
|
# User sliced with green PLA (tray_info_idx=GFA00)
|
|
# Two trays have GFA00: tray 3 (white) and tray 4 (green)
|
|
# Should pick tray 4 because the color matches
|
|
required = [
|
|
{"slot_id": 2, "type": "PLA", "color": "#00FF00", "tray_info_idx": "GFA00"}, # Green PLA
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FFFFFF", "global_tray_id": 3, "tray_info_idx": "GFA00"}, # White PLA
|
|
{"type": "PLA", "color": "#00FF00", "global_tray_id": 4, "tray_info_idx": "GFA00"}, # Green PLA
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [-1, 4] # Should pick tray 4 (color match), not tray 3 (first match)
|
|
|
|
def test_match_non_unique_tray_info_idx_same_color(self, scheduler):
|
|
"""Non-unique tray_info_idx with identical colors picks first match.
|
|
|
|
When multiple trays have the same tray_info_idx AND same color,
|
|
there's no way to differentiate, so first match is used.
|
|
"""
|
|
required = [
|
|
{"slot_id": 2, "type": "PLA", "color": "#FFFFFF", "tray_info_idx": "GFA00"},
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FFFFFF", "global_tray_id": 3, "tray_info_idx": "GFA00"},
|
|
{"type": "PLA", "color": "#FFFFFF", "global_tray_id": 4, "tray_info_idx": "GFA00"},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# Both have same color, so first is used
|
|
assert result == [-1, 3]
|
|
|
|
|
|
class TestPreferLowestFilament:
|
|
"""Test prefer_lowest_filament sorting in _match_filaments_to_slots."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_prefer_lowest_picks_lower_remain(self, scheduler):
|
|
"""When enabled, should pick the spool with lower remaining filament."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "remain": 80},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "remain": 30},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
assert result == [1] # Should pick tray 1 (30% remaining)
|
|
|
|
def test_prefer_lowest_disabled_picks_first(self, scheduler):
|
|
"""When disabled, should pick the first matching spool (default behavior)."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "remain": 80},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "remain": 30},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=False)
|
|
assert result == [0] # Should pick tray 0 (first match)
|
|
|
|
def test_prefer_lowest_unknown_remain_sorted_last(self, scheduler):
|
|
"""Spools with remain=-1 (unknown) should be sorted to end."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "remain": -1},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "remain": 50},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
assert result == [1] # Should pick tray 1 (known 50%) over unknown
|
|
|
|
def test_prefer_lowest_missing_remain_sorted_last(self, scheduler):
|
|
"""Spools without remain field should be sorted to end."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0}, # No remain field
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "remain": 50},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
assert result == [1] # Should pick tray 1 (known 50%) over missing
|
|
|
|
def test_prefer_lowest_multiple_slots(self, scheduler):
|
|
"""Should pick lowest remain for each slot independently."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000"},
|
|
{"slot_id": 2, "type": "PLA", "color": "#FF0000"},
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "remain": 80},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 1, "remain": 30},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 2, "remain": 60},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
# Slot 1 gets tray 1 (30%), slot 2 gets tray 2 (60%) — tray 0 (80%) unused
|
|
assert result == [1, 2]
|
|
|
|
def test_prefer_lowest_with_tray_info_idx(self, scheduler):
|
|
"""Should sort within tray_info_idx subset too."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FFFFFF", "tray_info_idx": "GFA00"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FFFFFF", "global_tray_id": 0, "tray_info_idx": "GFA00", "remain": 80},
|
|
{"type": "PLA", "color": "#FFFFFF", "global_tray_id": 1, "tray_info_idx": "GFA00", "remain": 20},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
assert result == [1] # Should pick tray 1 (20%) within idx subset
|
|
|
|
def test_prefer_lowest_external_spool(self, scheduler):
|
|
"""External spool with low remain should be preferred over AMS spool."""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "remain": 80, "is_external": False},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 254, "remain": 10, "is_external": True},
|
|
]
|
|
|
|
result = scheduler._match_filaments_to_slots(required, loaded, prefer_lowest=True)
|
|
assert result == [254] # Should pick external spool (10%) over AMS (80%)
|
|
|
|
|
|
class TestPreferLowestInventoryOverride:
|
|
"""Tests for the #1508 inventory-aware sort: when the user has bound a
|
|
Bambuddy inventory spool to an AMS slot, that spool's remaining weight
|
|
becomes the sort signal instead of the MQTT ``remain`` percentage.
|
|
|
|
The fix is two-tier: inventory-tracked spools always sort before
|
|
MQTT-only ones, then ascending by remaining within each tier, then
|
|
ascending by AMS slot position. See
|
|
``print_scheduler._prefer_lowest_sort_key`` for the rationale.
|
|
"""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_inventory_override_beats_mqtt_remain(self, scheduler):
|
|
"""Slot 4's inventory shows 50 g remaining; slot 1's clone has 950 g.
|
|
MQTT ``remain`` is -1 for both (non-RFID spools), so without the
|
|
override the sort collapses to AMS-slot order and slot 1 wins.
|
|
With the override slot 4 (the original, nearly empty) wins. This is
|
|
the literal reporter scenario in #1508.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": -1,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 3,
|
|
"global_tray_id": 3,
|
|
"remain": -1,
|
|
},
|
|
]
|
|
# Slot 1 (gtid 0) is the fresh clone at 950 g; slot 4 (gtid 3) is the
|
|
# nearly-empty original at 50 g.
|
|
overrides = {0: 950.0, 3: 50.0}
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=overrides
|
|
)
|
|
assert result == [3]
|
|
|
|
def test_inventory_override_with_zero_grams_still_wins(self, scheduler):
|
|
"""An inventory-tracked spool at 0 g must still sort first within
|
|
its tier — the user wants to finish what's left (or be told there's
|
|
a deficit) rather than skip to the fresh one. The clamp-to-101
|
|
legacy logic only fires on negative values, so 0 g stays 0.0.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": -1,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 1,
|
|
"global_tray_id": 1,
|
|
"remain": -1,
|
|
},
|
|
]
|
|
overrides = {0: 500.0, 1: 0.0}
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=overrides
|
|
)
|
|
assert result == [1]
|
|
|
|
def test_inventory_tier_beats_mqtt_tier_regardless_of_value(self, scheduler):
|
|
"""Mixed mode: one slot is inventory-tracked at 800 g (high), the
|
|
other has only a MQTT remain of 10 (very low). The inventory tier
|
|
wins because the user has explicitly told us to manage that slot —
|
|
unit-mixing across tiers is intentional and resolved by the tier
|
|
flag, not value comparison.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": 10,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 1,
|
|
"global_tray_id": 1,
|
|
"remain": -1,
|
|
},
|
|
]
|
|
overrides = {1: 800.0} # only slot 2 has an inventory binding
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=overrides
|
|
)
|
|
assert result == [1]
|
|
|
|
def test_two_tracked_spools_tied_at_same_grams_lower_slot_wins(self, scheduler):
|
|
"""Two inventory-tracked spools with genuinely equal remaining
|
|
weight — slot tie-breaker decides. Lower AMS slot wins to match
|
|
the user's mental model of "use the lower slot first when equal."
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 1,
|
|
"global_tray_id": 1,
|
|
"remain": -1,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": -1,
|
|
},
|
|
]
|
|
overrides = {0: 500.0, 1: 500.0}
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=overrides
|
|
)
|
|
assert result == [0]
|
|
|
|
def test_no_override_falls_back_to_mqtt_remain(self, scheduler):
|
|
"""When no slots are inventory-bound the override map is empty
|
|
and behaviour is identical to the pre-#1508 MQTT-only sort.
|
|
Regression guard for the un-tracked-spool case.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": 80,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 1,
|
|
"global_tray_id": 1,
|
|
"remain": 30,
|
|
},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides={}
|
|
)
|
|
assert result == [1]
|
|
|
|
def test_no_override_unknown_remain_sorts_after_known(self, scheduler):
|
|
"""In the no-binding case, ``remain = -1`` (non-RFID, unknown) must
|
|
still sort *after* a slot the printer knows something about — the
|
|
legacy sentinel-101 behaviour is preserved.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": -1,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 1,
|
|
"global_tray_id": 1,
|
|
"remain": 50,
|
|
},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=None
|
|
)
|
|
assert result == [1]
|
|
|
|
def test_external_with_negative_ams_id_does_not_outrank_ams_on_tie(self, scheduler):
|
|
"""``_build_loaded_filaments`` emits external/VT trays with
|
|
``ams_id = -1``. A naive ``ams_id * 4 + tray_id`` slot-priority
|
|
formula would compute -4 for an external and 0 for AMS slot 0 —
|
|
flipping the legacy stable-sort baseline (which kept AMS first
|
|
because it's emitted before externals). When ``remain`` ties
|
|
between the two, AMS slot 0 must still win.
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": -1,
|
|
"is_external": False,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": -1,
|
|
"tray_id": 0,
|
|
"global_tray_id": 254,
|
|
"remain": -1,
|
|
"is_external": True,
|
|
},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=None
|
|
)
|
|
assert result == [0]
|
|
|
|
def test_ams_ht_does_not_outrank_regular_ams_on_tie(self, scheduler):
|
|
"""AMS-HT units use ``ams_id`` >= 128 with a single tray. On a tied
|
|
``remain`` value, regular AMS slot 0 (slot_priority 0) must beat
|
|
AMS-HT (slot_priority 1000+).
|
|
"""
|
|
required = [{"slot_id": 1, "type": "PLA", "color": "#FF0000"}]
|
|
loaded = [
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 0,
|
|
"tray_id": 0,
|
|
"global_tray_id": 0,
|
|
"remain": 50,
|
|
},
|
|
{
|
|
"type": "PLA",
|
|
"color": "#FF0000",
|
|
"ams_id": 128,
|
|
"tray_id": 0,
|
|
"global_tray_id": 128,
|
|
"remain": 50,
|
|
},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(
|
|
required, loaded, prefer_lowest=True, inventory_remain_overrides=None
|
|
)
|
|
assert result == [0]
|
|
|
|
|
|
class TestBuildLoadedFilamentsTrayInfoIdx:
|
|
"""Test tray_info_idx extraction in _build_loaded_filaments."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_build_loaded_filaments_includes_tray_info_idx(self, scheduler):
|
|
"""Should extract tray_info_idx from AMS trays."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA", "tray_color": "000000", "tray_info_idx": "GFA00"},
|
|
{"id": 1, "tray_type": "PLA", "tray_color": "000000", "tray_info_idx": "GFA01"},
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 2
|
|
assert result[0]["tray_info_idx"] == "GFA00"
|
|
assert result[1]["tray_info_idx"] == "GFA01"
|
|
|
|
def test_build_loaded_filaments_empty_tray_info_idx(self, scheduler):
|
|
"""Missing tray_info_idx should default to empty string."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA", "tray_color": "FF0000"}, # No tray_info_idx
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["tray_info_idx"] == ""
|
|
|
|
def test_build_loaded_filaments_external_spool_tray_info_idx(self, scheduler):
|
|
"""Should extract tray_info_idx from external spool."""
|
|
|
|
class MockStatus:
|
|
raw_data = {"vt_tray": [{"tray_type": "TPU", "tray_color": "0000FF", "tray_info_idx": "P4d64437"}]}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["tray_info_idx"] == "P4d64437"
|
|
assert result[0]["is_external"] is True
|
|
|
|
|
|
def _make_3mf_zip(
|
|
project_settings: dict | None = None,
|
|
slice_info_xml: str | None = None,
|
|
) -> zipfile.ZipFile:
|
|
"""Create an in-memory ZipFile mimicking a 3MF with project_settings.config."""
|
|
buf = io.BytesIO()
|
|
with zipfile.ZipFile(buf, "w") as zf:
|
|
if project_settings is not None:
|
|
zf.writestr("Metadata/project_settings.config", json.dumps(project_settings))
|
|
if slice_info_xml is not None:
|
|
zf.writestr("Metadata/slice_info.config", slice_info_xml)
|
|
buf.seek(0)
|
|
return zipfile.ZipFile(buf, "r")
|
|
|
|
|
|
class TestExtractNozzleMappingFrom3mf:
|
|
"""Test the extract_nozzle_mapping_from_3mf utility."""
|
|
|
|
def test_group_id_priority_over_filament_nozzle_map(self):
|
|
"""group_id from slice_info should override filament_nozzle_map from project_settings.
|
|
|
|
Real-world scenario: "Auto For Flush" mode sets filament_nozzle_map all to 0
|
|
(user preference) but the actual assignment in slice_info has different group_ids.
|
|
"""
|
|
# filament_nozzle_map says all on slicer ext 0 → MQTT ext 1 (LEFT)
|
|
# But slice_info group_id says slot 6 → group 0 (LEFT), slot 12 → group 1 (RIGHT)
|
|
slice_info = """<?xml version="1.0" encoding="UTF-8"?>
|
|
<config>
|
|
<plate>
|
|
<filament id="6" type="PLA" color="#56B7E6" used_g="1.84" group_id="0"/>
|
|
<filament id="12" type="PLA" color="#B39B84" used_g="1.76" group_id="1"/>
|
|
</plate>
|
|
</config>"""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"filament_nozzle_map": ["0"] * 12,
|
|
"physical_extruder_map": ["1", "0"],
|
|
},
|
|
slice_info_xml=slice_info,
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
# group_id 0 → physical_extruder_map[0] = 1 (LEFT)
|
|
# group_id 1 → physical_extruder_map[1] = 0 (RIGHT)
|
|
assert result == {6: 1, 12: 0}
|
|
zf.close()
|
|
|
|
def test_fallback_to_filament_nozzle_map_without_group_id(self):
|
|
"""Should fall back to filament_nozzle_map when slice_info has no group_id."""
|
|
slice_info = """<?xml version="1.0" encoding="UTF-8"?>
|
|
<config>
|
|
<plate>
|
|
<filament id="1" type="PLA" color="#FF0000" used_g="5.0"/>
|
|
</plate>
|
|
</config>"""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"filament_nozzle_map": ["0", "1", "0"],
|
|
"physical_extruder_map": ["0", "1"],
|
|
},
|
|
slice_info_xml=slice_info,
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result == {1: 0, 2: 1, 3: 0}
|
|
zf.close()
|
|
|
|
def test_fallback_to_filament_nozzle_map_without_slice_info(self):
|
|
"""Should fall back to filament_nozzle_map when no slice_info.config exists."""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"filament_nozzle_map": ["0", "1", "0"],
|
|
"physical_extruder_map": ["0", "1"],
|
|
}
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result == {1: 0, 2: 1, 3: 0}
|
|
zf.close()
|
|
|
|
def test_single_nozzle_returns_none(self):
|
|
"""Single physical_extruder_map entry should return None (single-nozzle)."""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"filament_nozzle_map": ["0", "0", "0"],
|
|
"physical_extruder_map": ["0"],
|
|
}
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result is None
|
|
zf.close()
|
|
|
|
def test_missing_project_settings_returns_none(self):
|
|
"""Missing project_settings.config should return None."""
|
|
zf = _make_3mf_zip(None)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result is None
|
|
zf.close()
|
|
|
|
def test_missing_fields_returns_none(self):
|
|
"""Missing physical_extruder_map should return None."""
|
|
zf = _make_3mf_zip({"some_other_key": "value"})
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result is None
|
|
zf.close()
|
|
|
|
def test_physical_extruder_map_remapping(self):
|
|
"""Should apply physical_extruder_map to remap slicer extruder to MQTT extruder."""
|
|
# Slicer ext 0 -> MQTT ext 1, slicer ext 1 -> MQTT ext 0
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"filament_nozzle_map": ["0", "1"],
|
|
"physical_extruder_map": ["1", "0"],
|
|
}
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result == {1: 1, 2: 0}
|
|
zf.close()
|
|
|
|
def test_single_active_extruder_maps_all_slots(self):
|
|
"""When only one extruder has nozzles installed, all filaments map to it.
|
|
|
|
H2C scenario: left extruder has no nozzles (Standard#0|High Flow#0),
|
|
right extruder has one Standard nozzle (Standard#1). Print uses only
|
|
the right extruder, so all filaments should map to physical extruder 0.
|
|
"""
|
|
slice_info = """<?xml version="1.0" encoding="UTF-8"?>
|
|
<config>
|
|
<plate>
|
|
<filament id="1" type="PLA" color="#FF0000" used_g="5.0" group_id="0"/>
|
|
<filament id="2" type="PLA" color="#00FF00" used_g="3.0" group_id="0"/>
|
|
</plate>
|
|
</config>"""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"physical_extruder_map": ["1", "0"],
|
|
"extruder_nozzle_stats": ["Standard#0|High Flow#0", "Standard#1"],
|
|
},
|
|
slice_info_xml=slice_info,
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
# Only extruder index 1 is active → physical_extruder_map[1] = 0 (RIGHT)
|
|
assert result == {1: 0, 2: 0}
|
|
zf.close()
|
|
|
|
def test_two_active_extruders_falls_through(self):
|
|
"""When both extruders have nozzles, the single-active shortcut is skipped.
|
|
|
|
Should fall through to the normal group_id-based mapping.
|
|
"""
|
|
slice_info = """<?xml version="1.0" encoding="UTF-8"?>
|
|
<config>
|
|
<plate>
|
|
<filament id="1" type="PLA" color="#FF0000" used_g="5.0" group_id="0"/>
|
|
<filament id="2" type="PLA" color="#00FF00" used_g="3.0" group_id="1"/>
|
|
</plate>
|
|
</config>"""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"physical_extruder_map": ["1", "0"],
|
|
"extruder_nozzle_stats": ["Standard#1", "High Flow#1"],
|
|
},
|
|
slice_info_xml=slice_info,
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
# Both active → normal group_id mapping: group 0 → phys 1, group 1 → phys 0
|
|
assert result == {1: 1, 2: 0}
|
|
zf.close()
|
|
|
|
def test_missing_extruder_nozzle_stats_falls_through(self):
|
|
"""When extruder_nozzle_stats is absent, the single-active shortcut is skipped.
|
|
|
|
Should fall through to the normal group_id-based mapping.
|
|
"""
|
|
slice_info = """<?xml version="1.0" encoding="UTF-8"?>
|
|
<config>
|
|
<plate>
|
|
<filament id="1" type="PLA" color="#FF0000" used_g="5.0" group_id="0"/>
|
|
<filament id="2" type="PLA" color="#00FF00" used_g="3.0" group_id="1"/>
|
|
</plate>
|
|
</config>"""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"physical_extruder_map": ["1", "0"],
|
|
},
|
|
slice_info_xml=slice_info,
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
# No extruder_nozzle_stats → normal group_id mapping
|
|
assert result == {1: 1, 2: 0}
|
|
zf.close()
|
|
|
|
def test_single_active_extruder_no_slice_info_returns_none(self):
|
|
"""Single active extruder but no slice_info should return None."""
|
|
zf = _make_3mf_zip(
|
|
{
|
|
"physical_extruder_map": ["1", "0"],
|
|
"extruder_nozzle_stats": ["Standard#0", "Standard#1"],
|
|
},
|
|
)
|
|
result = extract_nozzle_mapping_from_3mf(zf)
|
|
assert result is None
|
|
zf.close()
|
|
|
|
|
|
class TestNozzleAwareMapping:
|
|
"""Test nozzle-aware filament matching in the print scheduler."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_dual_nozzle_matching(self, scheduler):
|
|
"""Filaments assigned to different nozzles should match to correct AMS units."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000", "nozzle_id": 0}, # Right nozzle
|
|
{"slot_id": 2, "type": "PLA", "color": "#00FF00", "nozzle_id": 1}, # Left nozzle
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#00FF00", "global_tray_id": 0, "extruder_id": 0}, # AMS0 on right
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 4, "extruder_id": 1}, # AMS1 on left
|
|
]
|
|
# Without nozzle filtering, slot 1 (red, right) would match tray 4 (red, left) by color.
|
|
# With nozzle filtering, slot 1 (right nozzle) can only use tray 0 (right extruder),
|
|
# and slot 2 (left nozzle) can only use tray 4 (left extruder).
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0, 4]
|
|
|
|
def test_nozzle_hard_filter_no_fallback(self, scheduler):
|
|
"""Hard filter: no fallback to wrong nozzle when target nozzle has no trays."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000", "nozzle_id": 0}, # Right nozzle
|
|
]
|
|
loaded = [
|
|
# Only a tray on the left nozzle, none on right
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 4, "extruder_id": 1},
|
|
]
|
|
# No trays on extruder 0 — hard filter returns -1, no cross-nozzle fallback
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [-1]
|
|
|
|
def test_no_nozzle_id_skips_filtering(self, scheduler):
|
|
"""When nozzle_id is None, no nozzle filtering should be applied."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FF0000"}, # No nozzle_id
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 0, "extruder_id": 0},
|
|
{"type": "PLA", "color": "#FF0000", "global_tray_id": 4, "extruder_id": 1},
|
|
]
|
|
# Should match first available (tray 0) regardless of extruder
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0]
|
|
|
|
def test_extruder_id_in_loaded_filaments(self, scheduler):
|
|
"""_build_loaded_filaments should include extruder_id from ams_extruder_map."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{"id": 0, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "FF0000"}]},
|
|
{"id": 1, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "00FF00"}]},
|
|
],
|
|
"ams_extruder_map": {"0": 0, "1": 1},
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 2
|
|
assert result[0]["extruder_id"] == 0
|
|
assert result[1]["extruder_id"] == 1
|
|
|
|
def test_extruder_id_none_without_map(self, scheduler):
|
|
"""extruder_id should be None when ams_extruder_map is absent."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"ams": [
|
|
{"id": 0, "tray": [{"id": 0, "tray_type": "PLA", "tray_color": "FF0000"}]},
|
|
]
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["extruder_id"] is None
|
|
|
|
def test_external_spool_extruder_id(self, scheduler):
|
|
"""External spool 254 (Ext-L) should have extruder_id=1 (LEFT) when ams_extruder_map exists."""
|
|
|
|
class MockStatus:
|
|
raw_data = {
|
|
"vt_tray": [{"tray_type": "TPU", "tray_color": "0000FF"}],
|
|
"ams_extruder_map": {"0": 0},
|
|
}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
# Default vt_tray id=254 → Ext-L → LEFT nozzle (extruder 1)
|
|
assert result[0]["extruder_id"] == 1
|
|
assert result[0]["is_external"] is True
|
|
|
|
def test_external_spool_no_extruder_map(self, scheduler):
|
|
"""External spool extruder_id should be None without ams_extruder_map."""
|
|
|
|
class MockStatus:
|
|
raw_data = {"vt_tray": [{"tray_type": "TPU", "tray_color": "0000FF"}]}
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
assert len(result) == 1
|
|
assert result[0]["extruder_id"] is None
|
|
|
|
def test_dual_nozzle_with_tray_info_idx(self, scheduler):
|
|
"""Nozzle filtering should work together with tray_info_idx matching."""
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA00", "nozzle_id": 0},
|
|
{"slot_id": 2, "type": "PLA", "color": "#000000", "tray_info_idx": "GFA01", "nozzle_id": 1},
|
|
]
|
|
loaded = [
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 0, "tray_info_idx": "GFA00", "extruder_id": 0},
|
|
{"type": "PLA", "color": "#000000", "global_tray_id": 4, "tray_info_idx": "GFA01", "extruder_id": 1},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [0, 4]
|
|
|
|
|
|
# ============================================================================
|
|
# MODEL-SPECIFIC TESTS: Real data from actual printers
|
|
# ============================================================================
|
|
|
|
|
|
def _h2d_raw_data():
|
|
"""H2D real data fixture (from live API response 2026-02-18).
|
|
|
|
Configuration:
|
|
LEFT nozzle (extruder 1): AMS 0 (4-slot), AMS 2 (4-slot)
|
|
RIGHT nozzle (extruder 0): AMS 1 (4-slot), AMS-HT 128 (1-slot, empty)
|
|
External: 254 (Ext-L, LEFT), 255 (Ext-R, RIGHT, empty)
|
|
|
|
ams_extruder_map: {"0": 1, "1": 0, "2": 1, "128": 0}
|
|
"""
|
|
return {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PETG", "tray_color": "FFFFFFFF", "tray_info_idx": "GFG02"},
|
|
{"id": 1, "tray_type": "PLA", "tray_color": "C8C8C8FF", "tray_info_idx": "GFA06"},
|
|
{"id": 2, "tray_type": "PETG", "tray_color": "875718FF", "tray_info_idx": "GFG02"},
|
|
{"id": 3, "tray_type": "PLA", "tray_color": "000000FF", "tray_info_idx": "GFA00"},
|
|
],
|
|
},
|
|
{
|
|
"id": 1,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA", "tray_color": "FFFFFFFF", "tray_info_idx": "GFA00"},
|
|
{"id": 1, "tray_type": "PETG", "tray_color": "000000FF", "tray_info_idx": "GFG02"},
|
|
{"id": 2, "tray_type": "PLA", "tray_color": "5F6367FF", "tray_info_idx": "GFA06"},
|
|
{"id": 3, "tray_type": "PLA", "tray_color": "B39B84FF", "tray_info_idx": "GFA02"},
|
|
],
|
|
},
|
|
{
|
|
"id": 128,
|
|
"tray": [{"id": 0}], # AMS-HT, empty
|
|
},
|
|
{
|
|
"id": 2,
|
|
"tray": [
|
|
{"id": 0, "tray_type": "PLA-S", "tray_color": "FFFFFFFF", "tray_info_idx": "P8aa1726"},
|
|
{"id": 1, "tray_type": "PLA", "tray_color": "56B7E6FF", "tray_info_idx": "PFUS9924"},
|
|
{"id": 2, "tray_type": "PETG", "tray_color": "6EE53CFF", "tray_info_idx": "GFG02"},
|
|
{"id": 3, "tray_type": "PLA", "tray_color": "FF0000FF", "tray_info_idx": "PFUS9ac9"},
|
|
],
|
|
},
|
|
],
|
|
"vt_tray": [
|
|
{"id": 254, "tray_type": "PLA", "tray_color": "000000FF", "tray_info_idx": "P4d64437"},
|
|
{"id": 255, "tray_type": "", "tray_color": "00000000"}, # empty
|
|
],
|
|
"ams_extruder_map": {"0": 1, "1": 0, "2": 1, "128": 0},
|
|
}
|
|
|
|
|
|
def _x1c_raw_data():
|
|
"""X1C real data fixture (from live API response 2026-02-18).
|
|
|
|
Configuration:
|
|
Single nozzle (extruder 0): AMS 0 (4-slot, all empty), AMS 1 (4-slot, 3 loaded)
|
|
External: 254 (single, empty)
|
|
|
|
ams_extruder_map: {"0": 0, "1": 0} ← NOT empty, all on extruder 0
|
|
"""
|
|
return {
|
|
"ams": [
|
|
{
|
|
"id": 0,
|
|
"tray": [
|
|
{"id": 0}, # empty
|
|
{"id": 1}, # empty
|
|
{"id": 2}, # empty
|
|
{"id": 3}, # empty
|
|
],
|
|
},
|
|
{
|
|
"id": 1,
|
|
"tray": [
|
|
{"id": 0}, # empty
|
|
{"id": 1, "tray_type": "PLA", "tray_color": "EBCFA6FF", "tray_info_idx": "PFUS22b2"},
|
|
{"id": 2, "tray_type": "PLA", "tray_color": "FCECD6FF", "tray_info_idx": "P4d64437"},
|
|
{"id": 3, "tray_type": "PLA", "tray_color": "0066FFFF", "tray_info_idx": "P4d64437"},
|
|
],
|
|
},
|
|
],
|
|
"vt_tray": [
|
|
{"id": 254, "tray_type": "", "tray_color": "00000000"}, # empty
|
|
],
|
|
"ams_extruder_map": {"0": 0, "1": 0},
|
|
}
|
|
|
|
|
|
class TestH2DModel:
|
|
"""H2D-specific tests with real printer data (dual nozzle, AMS-HT)."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_build_loaded_filaments_h2d(self, scheduler):
|
|
"""H2D: correct extruder_id, global_tray_id, AMS-HT handling."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
|
|
# Should have 13 loaded filaments (4 + 4 + 0 + 4 + 1 external)
|
|
assert len(result) == 13
|
|
|
|
# AMS 0 trays → extruder 1 (LEFT)
|
|
ams0 = [f for f in result if f["ams_id"] == 0]
|
|
assert len(ams0) == 4
|
|
assert all(f["extruder_id"] == 1 for f in ams0)
|
|
assert [f["global_tray_id"] for f in ams0] == [0, 1, 2, 3]
|
|
|
|
# AMS 1 trays → extruder 0 (RIGHT)
|
|
ams1 = [f for f in result if f["ams_id"] == 1]
|
|
assert len(ams1) == 4
|
|
assert all(f["extruder_id"] == 0 for f in ams1)
|
|
assert [f["global_tray_id"] for f in ams1] == [4, 5, 6, 7]
|
|
|
|
# AMS-HT 128 → empty, should not appear
|
|
ams_ht = [f for f in result if f["ams_id"] == 128]
|
|
assert len(ams_ht) == 0
|
|
|
|
# AMS 2 trays → extruder 1 (LEFT)
|
|
ams2 = [f for f in result if f["ams_id"] == 2]
|
|
assert len(ams2) == 4
|
|
assert all(f["extruder_id"] == 1 for f in ams2)
|
|
assert [f["global_tray_id"] for f in ams2] == [8, 9, 10, 11]
|
|
|
|
def test_external_spool_extruder_h2d(self, scheduler):
|
|
"""H2D: Ext-L (254) = LEFT (extruder 1), Ext-R (255) = RIGHT (extruder 0)."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
ext = [f for f in result if f["is_external"]]
|
|
assert len(ext) == 1 # Only 254 has filament
|
|
assert ext[0]["global_tray_id"] == 254
|
|
# Ext-L (254) should be LEFT nozzle (extruder 1)
|
|
assert ext[0]["extruder_id"] == 1
|
|
|
|
def test_match_left_nozzle_only(self, scheduler):
|
|
"""H2D: left-nozzle requirement only matches left-nozzle AMS."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#000000", "nozzle_id": 1}, # LEFT
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# Black PLA on LEFT: AMS 0 T4 (global 3)
|
|
assert result == [3]
|
|
|
|
def test_match_right_nozzle_only(self, scheduler):
|
|
"""H2D: right-nozzle requirement only matches right-nozzle AMS."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FFFFFF", "nozzle_id": 0}, # RIGHT
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# White PLA on RIGHT: AMS 1 T1 (global 4)
|
|
assert result == [4]
|
|
|
|
def test_reject_cross_nozzle(self, scheduler):
|
|
"""H2D: hard filter rejects cross-nozzle assignment."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
# PLA-S only exists on AMS 2 T1 (LEFT), require on RIGHT
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA-S", "color": "#FFFFFF", "nozzle_id": 0},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [-1] # No fallback to wrong nozzle
|
|
|
|
def test_dual_nozzle_multi_filament(self, scheduler):
|
|
"""H2D: multi-filament print maps to correct nozzles."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PETG", "color": "#FFFFFF", "nozzle_id": 1, "tray_info_idx": "GFG02"},
|
|
{"slot_id": 2, "type": "PLA", "color": "#FFFFFF", "nozzle_id": 0, "tray_info_idx": "GFA00"},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# PETG white on LEFT: AMS 0 T1 (global 0)
|
|
# PLA white on RIGHT: AMS 1 T1 (global 4)
|
|
assert result == [0, 4]
|
|
|
|
def test_external_spool_matches_on_correct_nozzle(self, scheduler):
|
|
"""H2D: external spool on left nozzle matches left-nozzle requirement."""
|
|
|
|
class MockStatus:
|
|
raw_data = _h2d_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#000000", "nozzle_id": 1, "tray_info_idx": "P4d64437"},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [254] # External spool on left nozzle
|
|
|
|
|
|
class TestX1CModel:
|
|
"""X1C-specific tests with real printer data (single nozzle, 2x regular AMS)."""
|
|
|
|
@pytest.fixture
|
|
def scheduler(self):
|
|
return PrintScheduler()
|
|
|
|
def test_build_loaded_filaments_x1c(self, scheduler):
|
|
"""X1C: all filaments on extruder 0, correct global_tray_id."""
|
|
|
|
class MockStatus:
|
|
raw_data = _x1c_raw_data()
|
|
|
|
result = scheduler._build_loaded_filaments(MockStatus())
|
|
|
|
# Only 3 loaded (AMS 1 trays 1-3)
|
|
assert len(result) == 3
|
|
# All on extruder 0
|
|
assert all(f["extruder_id"] == 0 for f in result)
|
|
# Correct global tray IDs
|
|
assert [f["global_tray_id"] for f in result] == [5, 6, 7]
|
|
|
|
def test_single_nozzle_no_filtering(self, scheduler):
|
|
"""X1C: single-nozzle 3MF has no nozzle_id, all trays available."""
|
|
|
|
class MockStatus:
|
|
raw_data = _x1c_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#0066FF"}, # No nozzle_id
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# Blue PLA → AMS 1 T4 (global 7)
|
|
assert result == [7]
|
|
|
|
def test_tray_info_idx_matching_x1c(self, scheduler):
|
|
"""X1C: tray_info_idx matching works across AMS units."""
|
|
|
|
class MockStatus:
|
|
raw_data = _x1c_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#EBCFA6", "tray_info_idx": "PFUS22b2"},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# Unique tray_info_idx → AMS 1 T2 (global 5)
|
|
assert result == [5]
|
|
|
|
def test_non_unique_tray_info_idx_color_match_x1c(self, scheduler):
|
|
"""X1C: non-unique tray_info_idx falls back to color matching."""
|
|
|
|
class MockStatus:
|
|
raw_data = _x1c_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
# P4d64437 appears in AMS 1 T3 and T4
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#FCECD6", "tray_info_idx": "P4d64437"},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
# Should pick AMS 1 T3 (global 6, color FCECD6) over T4 (0066FF)
|
|
assert result == [6]
|
|
|
|
def test_multi_filament_x1c(self, scheduler):
|
|
"""X1C: multi-filament print matches freely across AMS units."""
|
|
|
|
class MockStatus:
|
|
raw_data = _x1c_raw_data()
|
|
|
|
loaded = scheduler._build_loaded_filaments(MockStatus())
|
|
required = [
|
|
{"slot_id": 1, "type": "PLA", "color": "#EBCFA6"},
|
|
{"slot_id": 2, "type": "PLA", "color": "#0066FF"},
|
|
]
|
|
result = scheduler._match_filaments_to_slots(required, loaded)
|
|
assert result == [5, 7]
|