raydriver 0.2.0__tar.gz → 0.3.0__tar.gz

{raydriver-0.2.0 → raydriver-0.3.0}/Cargo.lock

@@ -893,7 +893,7 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
 [[package]]
 name = "raydriver"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "async-trait",
  "env_filter 0.1.4",

{raydriver-0.2.0 → raydriver-0.3.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "raydriver"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 description = "Rust-native machine drivers for Rayforge, with Python bindings"
 readme = "README.md"

{raydriver-0.2.0 → raydriver-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raydriver
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{raydriver-0.2.0 → raydriver-0.3.0}/python/raydriver/grbl/parser/__init__.pyi

@@ -19,6 +19,7 @@ __all__ = [
     "parse_grbl_parser_state",
     "parse_grbl_settings",
     "parse_msg",
+    "parse_opt_flags",
     "parse_opt_info",
     "parse_probe_line",
     "parse_setting_pairs",
@@ -87,6 +88,11 @@ def parse_msg(line: builtins.str) -> typing.Optional[tuple[builtins.str, builtin
     Parse a `[MSG:key:value]` line into `(key, value)`.
     """
 
+def parse_opt_flags(line: builtins.str) -> typing.Optional[builtins.str]:
+    r"""
+    Extract the compile option flags from an `[OPT:...]` line.
+    """
+
 def parse_opt_info(line: builtins.str) -> typing.Optional[builtins.int]:
     r"""
     Extract the RX buffer size from an `[OPT:...]` line.

{raydriver-0.2.0 → raydriver-0.3.0}/python/raydriver/grbl/types/__init__.pyi

@@ -25,6 +25,7 @@ class DeviceError:
     @property
     def description(self) -> builtins.str: ...
     def __eq__(self, other: builtins.object, /) -> builtins.bool: ...
+    def __new__(cls, code: builtins.int, title: builtins.str, description: builtins.str) -> DeviceError: ...
     def __repr__(self) -> builtins.str: ...
 
 @typing.final
@@ -34,31 +35,49 @@ class DeviceState:
     """
     @property
     def status(self) -> DeviceStatus: ...
+    @status.setter
+    def status(self, value: DeviceStatus) -> None: ...
     @property
     def error(self) -> typing.Optional[DeviceError]: ...
+    @error.setter
+    def error(self, value: typing.Optional[DeviceError]) -> None: ...
     @property
     def machine_pos(self) -> builtins.list[typing.Optional[builtins.float]]:
         r"""
         Machine position in mm; entries may be `None`.
         """
+    @machine_pos.setter
+    def machine_pos(self, value: typing.Sequence[typing.Optional[builtins.float]]) -> None: ...
     @property
     def work_pos(self) -> builtins.list[typing.Optional[builtins.float]]:
         r"""
         Work position in mm; entries may be `None`.
         """
+    @work_pos.setter
+    def work_pos(self, value: typing.Sequence[typing.Optional[builtins.float]]) -> None: ...
     @property
     def wco(self) -> builtins.list[typing.Optional[builtins.float]]:
         r"""
         Work coordinate offset in mm; entries may be `None`.
         """
+    @wco.setter
+    def wco(self, value: typing.Sequence[typing.Optional[builtins.float]]) -> None: ...
     @property
     def feed_rate(self) -> typing.Optional[builtins.int]: ...
+    @feed_rate.setter
+    def feed_rate(self, value: typing.Optional[builtins.int]) -> None: ...
     @property
     def spindle_speed(self) -> typing.Optional[builtins.int]: ...
+    @spindle_speed.setter
+    def spindle_speed(self, value: typing.Optional[builtins.int]) -> None: ...
     @property
     def buffer_available(self) -> typing.Optional[builtins.int]: ...
+    @buffer_available.setter
+    def buffer_available(self, value: typing.Optional[builtins.int]) -> None: ...
     @property
     def buffer_rx_available(self) -> typing.Optional[builtins.int]: ...
+    @buffer_rx_available.setter
+    def buffer_rx_available(self, value: typing.Optional[builtins.int]) -> None: ...
     def __eq__(self, other: builtins.object, /) -> builtins.bool: ...
     def __new__(cls) -> DeviceState: ...
     def __repr__(self) -> builtins.str: ...

{raydriver-0.2.0 → raydriver-0.3.0}/src/grbl/parser.rs

@@ -262,6 +262,12 @@ pub fn parse_opt_info(line: &str) -> Option<i64> {
         .and_then(|caps| caps[3].parse::<i64>().ok())
 }
 
+/// Extract the compile option flags from an
+/// `[OPT:<flags>,<planner_buffer_blocks>,<rx_buffer_size>]` line.
+pub fn parse_opt_flags(line: &str) -> Option<String> {
+    GRBL_OPT_RE.captures(line).map(|caps| caps[1].to_string())
+}
+
 /// Parses the response from a '$G' command to find the active WCS.
 /// Example response: `[G54 G17 G21 G90 G94 M5 M9 T0 F0 S0]`
 pub fn parse_grbl_parser_state(response_lines: &[String]) -> Option<String> {

{raydriver-0.2.0 → raydriver-0.3.0}/src/python/grbl/parser.rs

@@ -60,6 +60,13 @@ fn parse_opt_info(line: &str) -> Option<i64> {
     parser::parse_opt_info(line)
 }
 
+/// Extract the compile option flags from an `[OPT:...]` line.
+#[gen_stub_pyfunction(module = "raydriver.grbl.parser")]
+#[pyfunction]
+fn parse_opt_flags(line: &str) -> Option<String> {
+    parser::parse_opt_flags(line)
+}
+
 /// Parse a `[MSG:key:value]` line into `(key, value)`.
 #[gen_stub_pyfunction(module = "raydriver.grbl.parser")]
 #[pyfunction]
@@ -202,6 +209,7 @@ pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
             "parse_version",
             "parse_ver",
             "parse_opt_info",
+            "parse_opt_flags",
             "parse_msg",
             "extract_device_name",
             "extract_device_name_from_output",
@@ -225,6 +233,7 @@ pub(crate) fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(pyo3::wrap_pyfunction!(parse_version, m.clone())?)?;
     m.add_function(pyo3::wrap_pyfunction!(parse_ver, m.clone())?)?;
     m.add_function(pyo3::wrap_pyfunction!(parse_opt_info, m.clone())?)?;
+    m.add_function(pyo3::wrap_pyfunction!(parse_opt_flags, m.clone())?)?;
     m.add_function(pyo3::wrap_pyfunction!(parse_msg, m.clone())?)?;
     m.add_function(pyo3::wrap_pyfunction!(extract_device_name, m.clone())?)?;
     m.add_function(pyo3::wrap_pyfunction!(

{raydriver-0.2.0 → raydriver-0.3.0}/src/python/grbl/types.rs

@@ -18,7 +18,7 @@ pyo3_stub_gen::module_doc!("raydriver.grbl.types", "{}", MODULE_DOC);
 
 /// Machine state as reported in Grbl status reports.
 #[gen_stub_pyclass_enum]
-#[pyclass(module = "raydriver.grbl.types", eq, eq_int, skip_from_py_object)]
+#[pyclass(module = "raydriver.grbl.types", eq, eq_int, from_py_object)]
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum DeviceStatus {
     #[pyo3(name = "UNKNOWN")]
@@ -78,6 +78,29 @@ impl From<core::DeviceStatus> for DeviceStatus {
     }
 }
 
+impl From<DeviceStatus> for core::DeviceStatus {
+    fn from(status: DeviceStatus) -> Self {
+        match status {
+            DeviceStatus::Unknown => Self::Unknown,
+            DeviceStatus::Idle => Self::Idle,
+            DeviceStatus::Run => Self::Run,
+            DeviceStatus::Hold => Self::Hold,
+            DeviceStatus::Jog => Self::Jog,
+            DeviceStatus::Alarm => Self::Alarm,
+            DeviceStatus::Door => Self::Door,
+            DeviceStatus::Check => Self::Check,
+            DeviceStatus::Home => Self::Home,
+            DeviceStatus::Sleep => Self::Sleep,
+            DeviceStatus::Tool => Self::Tool,
+            DeviceStatus::Queue => Self::Queue,
+            DeviceStatus::Lock => Self::Lock,
+            DeviceStatus::Unlock => Self::Unlock,
+            DeviceStatus::Cycle => Self::Cycle,
+            DeviceStatus::Test => Self::Test,
+        }
+    }
+}
+
 #[gen_stub_pymethods]
 #[pymethods]
 impl DeviceStatus {
@@ -110,7 +133,7 @@ impl DeviceStatus {
 
 /// An error or alarm with code, title and description.
 #[gen_stub_pyclass]
-#[pyclass(module = "raydriver.grbl.types", eq, skip_from_py_object)]
+#[pyclass(module = "raydriver.grbl.types", eq, from_py_object)]
 #[derive(Clone, PartialEq)]
 pub struct DeviceError {
     pub(crate) inner: core::DeviceError,
@@ -125,6 +148,13 @@ impl DeviceError {
 #[gen_stub_pymethods]
 #[pymethods]
 impl DeviceError {
+    #[new]
+    fn new_py(code: i32, title: String, description: String) -> Self {
+        Self {
+            inner: core::DeviceError::new(code, &title, &description),
+        }
+    }
+
     #[getter]
     fn code(&self) -> i32 {
         self.inner.code
@@ -174,49 +204,94 @@ impl DeviceState {
         self.inner.status.into()
     }
 
+    #[setter]
+    fn set_status(&mut self, status: DeviceStatus) {
+        self.inner.status = status.into();
+    }
+
     #[getter]
     fn error(&self) -> Option<DeviceError> {
         self.inner.error.clone().map(DeviceError::new)
     }
 
+    #[setter]
+    fn set_error(&mut self, error: Option<&DeviceError>) {
+        self.inner.error = error.map(|e| e.inner.clone());
+    }
+
     /// Machine position in mm; entries may be `None`.
     #[getter]
     fn machine_pos(&self) -> Vec<Option<f64>> {
         self.inner.machine_pos.clone()
     }
 
+    #[setter]
+    fn set_machine_pos(&mut self, pos: Vec<Option<f64>>) {
+        self.inner.machine_pos = pos;
+    }
+
     /// Work position in mm; entries may be `None`.
     #[getter]
     fn work_pos(&self) -> Vec<Option<f64>> {
         self.inner.work_pos.clone()
     }
 
+    #[setter]
+    fn set_work_pos(&mut self, pos: Vec<Option<f64>>) {
+        self.inner.work_pos = pos;
+    }
+
     /// Work coordinate offset in mm; entries may be `None`.
     #[getter]
     fn wco(&self) -> Vec<Option<f64>> {
         self.inner.wco.clone()
     }
 
+    #[setter]
+    fn set_wco(&mut self, wco: Vec<Option<f64>>) {
+        self.inner.wco = wco;
+    }
+
     #[getter]
     fn feed_rate(&self) -> Option<i64> {
         self.inner.feed_rate
     }
 
+    #[setter]
+    fn set_feed_rate(&mut self, feed_rate: Option<i64>) {
+        self.inner.feed_rate = feed_rate;
+    }
+
     #[getter]
     fn spindle_speed(&self) -> Option<i64> {
         self.inner.spindle_speed
     }
 
+    #[setter]
+    fn set_spindle_speed(&mut self, spindle_speed: Option<i64>) {
+        self.inner.spindle_speed = spindle_speed;
+    }
+
     #[getter]
     fn buffer_available(&self) -> Option<i64> {
         self.inner.buffer_available
     }
 
+    #[setter]
+    fn set_buffer_available(&mut self, buffer_available: Option<i64>) {
+        self.inner.buffer_available = buffer_available;
+    }
+
     #[getter]
     fn buffer_rx_available(&self) -> Option<i64> {
         self.inner.buffer_rx_available
     }
 
+    #[setter]
+    fn set_buffer_rx_available(&mut self, buffer_rx_available: Option<i64>) {
+        self.inner.buffer_rx_available = buffer_rx_available;
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "DeviceState(status={}, feed_rate={:?})",

raydriver-0.2.0/tests/test_parser.py → raydriver-0.3.0/tests/test_grbl_parser.py

@@ -14,6 +14,7 @@ from raydriver.grbl.parser import (
     parse_grbl_parser_state,
     parse_grbl_settings,
     parse_msg,
+    parse_opt_flags,
     parse_opt_info,
     parse_probe_line,
     parse_setting_pairs,
@@ -336,6 +337,16 @@ class TestOptInfo:
         assert parse_opt_info("ok") is None
 
 
+class TestOptFlags:
+    def test_valid(self):
+        assert parse_opt_flags("[OPT:V,15,127]") == "V"
+        assert parse_opt_flags("[OPT:VMPH,63,511]") == "VMPH"
+
+    def test_invalid(self):
+        assert parse_opt_flags("[VER:1.1h:]") is None
+        assert parse_opt_flags("ok") is None
+
+
 class TestParseMsg:
     def test_valid(self):
         assert parse_msg("[MSG:machine:Ortur]") == ("machine", "Ortur")

raydriver-0.3.0/tests/test_grbl_types.py

@@ -0,0 +1,171 @@
+"""Tests for the shared value types: DeviceState, DeviceStatus and
+DeviceError.
+
+Covers the Python-facing construction surface (setters and the
+DeviceError constructor) and the merge/round-trip contract that
+embedders rely on when they keep their own state object and feed it
+back to ``parse_state`` as the default.
+"""
+
+from raydriver.grbl.parser import parse_state
+from raydriver.grbl.types import DeviceError, DeviceState, DeviceStatus
+
+
+def build_state(**overrides) -> DeviceState:
+    """A fully populated DeviceState, built through the Python
+    setters, with optional per-field overrides."""
+    state = DeviceState()
+    state.status = overrides.get("status", DeviceStatus.RUN)
+    state.error = overrides.get("error", None)
+    state.machine_pos = overrides.get("machine_pos", [11.0, 22.0, 33.0])
+    state.work_pos = overrides.get("work_pos", [10.0, 20.0, 30.0])
+    state.wco = overrides.get("wco", [1.0, 2.0, 3.0])
+    state.feed_rate = overrides.get("feed_rate", 500)
+    state.spindle_speed = overrides.get("spindle_speed", 1000)
+    state.buffer_available = overrides.get("buffer_available", 62)
+    state.buffer_rx_available = overrides.get("buffer_rx_available", 100)
+    return state
+
+
+class TestDeviceStateDefaults:
+    def test_fresh_state_defaults(self):
+        state = DeviceState()
+        assert state.status == DeviceStatus.UNKNOWN
+        assert state.error is None
+        assert state.machine_pos == [None, None, None]
+        assert state.work_pos == [None, None, None]
+        assert state.wco == [0.0, 0.0, 0.0]
+        assert state.feed_rate is None
+        assert state.spindle_speed is None
+        assert state.buffer_available is None
+        assert state.buffer_rx_available is None
+
+    def test_status_name(self):
+        assert DeviceStatus.ALARM.name == "ALARM"
+        assert parse_state("<Idle|MPos:1,2,3>").status.name == "IDLE"
+
+
+class TestDeviceStateSetters:
+    def test_set_all_fields(self):
+        state = build_state()
+        assert state.status == DeviceStatus.RUN
+        assert state.machine_pos == [11.0, 22.0, 33.0]
+        assert state.work_pos == [10.0, 20.0, 30.0]
+        assert state.wco == [1.0, 2.0, 3.0]
+        assert state.feed_rate == 500
+        assert state.spindle_speed == 1000
+        assert state.buffer_available == 62
+        assert state.buffer_rx_available == 100
+
+    def test_set_error(self):
+        state = DeviceState()
+        error = DeviceError(20, "Unsupported Command", "details")
+        state.error = error
+        assert state.error == error
+        assert state.error.code == 20
+        assert state.error.title == "Unsupported Command"
+        assert state.error.description == "details"
+
+    def test_clear_error_with_none(self):
+        state = build_state(error=DeviceError(1, "t", "d"))
+        state.error = None
+        assert state.error is None
+
+    def test_unknown_entries_survive_setter(self):
+        state = DeviceState()
+        state.machine_pos = [1.0, None, 3.0]
+        assert state.machine_pos == [1.0, None, 3.0]
+
+    def test_status_from_member_lookup(self):
+        state = DeviceState()
+        state.status = getattr(DeviceStatus, "HOLD")
+        assert state.status == DeviceStatus.HOLD
+
+
+class TestDeviceStateEquality:
+    def test_equal_states_compare_equal(self):
+        assert build_state() == build_state()
+
+    def test_status_difference_compares_unequal(self):
+        assert build_state() != build_state(status=DeviceStatus.IDLE)
+
+    def test_error_difference_compares_unequal(self):
+        plain = build_state()
+        failing = build_state(error=DeviceError(9, "t", "d"))
+        assert plain != failing
+
+    def test_position_difference_compares_unequal(self):
+        assert build_state() != build_state(machine_pos=[1.0, 2.0, 3.0])
+
+
+class TestDeviceError:
+    def test_constructor_and_getters(self):
+        error = DeviceError(9, "Commands Locked", "Clear the alarm state.")
+        assert error.code == 9
+        assert error.title == "Commands Locked"
+        assert error.description == "Clear the alarm state."
+
+    def test_equality(self):
+        assert DeviceError(1, "a", "b") == DeviceError(1, "a", "b")
+        assert DeviceError(1, "a", "b") != DeviceError(2, "a", "b")
+
+    def test_repr_contains_code_and_title(self):
+        text = repr(DeviceError(7, "Memory Error", "d"))
+        assert "7" in text
+        assert "Memory Error" in text
+
+
+class TestParseStateWithBuiltDefault:
+    """parse_state merges the report into a caller-provided default;
+    the default may be a state constructed through the Python
+    setters (the round-trip embedders depend on)."""
+
+    def test_report_updates_status_of_built_state(self):
+        state = parse_state(
+            "<Idle|MPos:1.0,2.0,3.0>", build_state(status=DeviceStatus.ALARM)
+        )
+        assert state.status == DeviceStatus.IDLE
+        assert state.error is None
+
+    def test_report_keeps_unreported_fields_of_built_state(self):
+        state = parse_state(
+            "<Idle|WPos:10.0,20.0,30.0>",
+            build_state(feed_rate=500, wco=[1.0, 2.0, 3.0]),
+        )
+        assert state.feed_rate == 500
+        assert state.machine_pos == [11.0, 22.0, 33.0]
+
+    def test_alarm_report_sets_error_on_built_state(self):
+        state = parse_state("<Alarm:1|FS:500,0>", build_state(feed_rate=100))
+        assert state.status == DeviceStatus.ALARM
+        assert state.error is not None
+        assert state.error.code == 1
+        assert state.feed_rate == 500
+
+    def test_repeated_merge_is_stable(self):
+        merged = build_state()
+        for _ in range(3):
+            merged = parse_state("<Hold|MPos:11.0,22.0,33.0>", merged)
+        assert merged.status == DeviceStatus.HOLD
+        assert merged.machine_pos == [11.0, 22.0, 33.0]
+        assert merged.feed_rate == 500
+
+
+class TestStateRoundTrip:
+    """Copying a parsed state field-by-field through the setters
+    reproduces it exactly — the contract the Rayforge conversion
+    helpers implement."""
+
+    def test_copy_via_setters_reproduces_parsed_state(self):
+        parsed = parse_state("<Run|MPos:1.0,2.0,3.0|FS:800,50|Bf:14,120>")
+        copy = DeviceState()
+        copy.status = parsed.status
+        copy.error = parsed.error
+        copy.machine_pos = parsed.machine_pos
+        copy.work_pos = parsed.work_pos
+        copy.wco = parsed.wco
+        copy.feed_rate = parsed.feed_rate
+        copy.spindle_speed = parsed.spindle_speed
+        copy.buffer_available = parsed.buffer_available
+        copy.buffer_rx_available = parsed.buffer_rx_available
+        assert copy == parsed