Fix SSM module typos, enum mismatches, and stream robustness

[jfichtner]

Summary

• Fix cherk_errors typo in 6 locations across ssm_source_module.py and ssm_measure_module.py. The misspelled keyword argument was silently ignored, leaving error checking enabled when the intent was to suppress it.
• Fix set_resistance_mode() enum check from ResistanceExcitationType to ResistanceMode in ssm_measure_module.py.
• Reconcile DataSourceMnemonic enum with data_source_types dict: add SSWeeping entry and SOURCE_IS_SETTLING member so both are usable via the enum API and streaming/fetch API.
• Fix stream_data generator robustness: add try/finally with TRACe:STOp cleanup, inner break when num_points reached, incomplete row validation before struct.unpack, and 10ms polling backoff.
• Add length validation before datetime() construction in calibration date methods.
• Handle wakepy import failure gracefully with a no-op context manager fallback, preventing NameError when wakepy is unavailable.
• Document lock ordering invariant (stream_lock before dut_lock) to prevent future deadlock regressions.
• Add tests verifying TRACe:STOp is sent on both normal completion and early generator abandonment.

Test plan

• python -m pytest tests/test_ssm_system.py -v — 311 tests passing (309 existing + 2 new)
• Verify on physical M81 hardware that streaming works correctly with early break
• Verify on a system without wakepy installed that stream_data works

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Fixes multiple SSM/M81 integration issues (typos, enum mismatches) and improves streaming robustness/cleanup behavior.

Changes:

• Adds generator cleanup (TRACe:STOp) and polling backoff to stream_data, plus calibration-date response validation.
• Extends data source support (SSWeeping, SOURCE_IS_SETTLING) and corrects enum/type checks.
• Adds tests to verify streaming stop behavior on normal completion and early generator abandonment.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
tests/test_ssm_system.py	Adds coverage ensuring TRACe:STOp is sent on stream completion and early close.
lakeshore/ssm_system_enums.py	Extends DataSourceMnemonic with SOURCE_IS_SETTLING.
lakeshore/ssm_system.py	Improves stream_data cleanup/robustness, adds wakepy fallback, and validates calibration date responses.
lakeshore/ssm_source_module.py	Fixes check_errors kwarg typo in multiple queries.
lakeshore/ssm_measure_module.py	Fixes check_errors kwarg typo and corrects enum type used in set_resistance_mode.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Breaking on an incomplete trailing row discards the remainder bytes. If TRACe:DATA:ALL? can return chunks that aren’t aligned to bytes_per_row, this will permanently lose data and corrupt subsequent struct.unpack alignment. Instead, keep a remainder buffer across iterations (prepend remainder + new_bytes, process only full rows, and carry the leftover bytes into the next loop) rather than skipping/breaking.

[Copilot]

The PR description says the DataSourceMnemonic enum is being reconciled with the data_source_types dict, but in the shown diffs: (1) SSWeeping is added to data_source_types without a corresponding enum member, and (2) SOURCE_IS_SETTLING (SRSettling) is added to the enum without a corresponding entry in data_source_types. This leaves the enum API and streaming/fetch conversion mapping out of sync—add the missing enum entry for SSWeeping and add a parser entry for SRSettling in data_source_types (or remove/rename to match the instrument mnemonic used by the mapping).

Suggested change

SOURCE_IS_SETTLING = 'SRSettling'

[Copilot]

The docstring claim about cleanup on 'garbage collection' is stronger than Python generally guarantees (timing of generator finalization can be implementation-dependent). Consider softening this to 'when the generator is closed/finalized (e.g., via exhaustion, close(), or GC finalization) we attempt best-effort cleanup' to avoid implying a deterministic guarantee.

Suggested change

	A TRACe:STOp command is sent when the generator exits for any reason
	(normal completion, caller break, exception, or garbage collection)
	to ensure instrument-side cleanup.
	When the generator is closed or finalized (for example due to normal
	completion, caller break, an exception, or garbage-collection
	finalization), it attempts to send a TRACe:STOp command as a
	best-effort instrument-side cleanup.

[Copilot]

The new error message doesn’t include the raw response payload, which is often the key detail when diagnosing instrument/firmware parsing issues. Consider including the original response (or the pre-split string) in the exception message, e.g. ... got {len(response)}: {response!r} (and similarly for the self-calibration date).

[Copilot]

New behavior was added for (a) incomplete trailing rows and (b) batches that contain more rows than needed to reach num_points, but the new tests only assert TRACe:STOp is sent. Add a unit test that simulates a TRACe:DATA:ALL? response containing a partial row followed by the remainder in a subsequent poll (and another that returns more than num_points rows in one batch) to validate correct point yield counts and no data loss.

Suggested change

	while num_points is None or num_collected < num_points:
	b64_string = ''
	while not b64_string:
	b64_string = self.query('TRACe:DATA:ALL?', check_errors=False)
	if not b64_string:
	time.sleep(0.01)
	new_bytes = b64decode(b64_string)
	rows = [new_bytes[i:i + bytes_per_row] for i in range(0, len(new_bytes), bytes_per_row)]
	for row in rows:
	if len(row) < bytes_per_row:
	# Incomplete trailing row from non-evenly-divisible buffer
	logger.debug('Skipping incomplete row (%d/%d bytes)', len(row), bytes_per_row)
	break
	if num_points is not None and num_collected >= num_points:
	# Batch contained more rows than needed to reach num_points
	break
	pending_bytes = b''
	done = False
	while not done and (num_points is None or num_collected < num_points):
	b64_string = ''
	while not b64_string:
	b64_string = self.query('TRACe:DATA:ALL?', check_errors=False)
	if not b64_string:
	time.sleep(0.01)
	# Combine any leftover bytes from the previous poll with the newly decoded data.
	new_bytes = pending_bytes + b64decode(b64_string)
	total_len = len(new_bytes)
	if total_len < bytes_per_row:
	# Not enough data to form a full row yet; keep buffering.
	pending_bytes = new_bytes
	continue
	full_rows_len = (total_len // bytes_per_row) * bytes_per_row
	full_rows_bytes = new_bytes[:full_rows_len]
	pending_bytes = new_bytes[full_rows_len:]
	for i in range(0, full_rows_len, bytes_per_row):
	if num_points is not None and num_collected >= num_points:
	# Batch contained more rows than needed to reach num_points
	done = True
	break
	row = full_rows_bytes[i:i + bytes_per_row]

[Copilot]

The two new tests duplicate the same data/packing setup logic. Consider extracting a small helper within the test class (or reusing the setup used by test_stream_data) to build encoded_data and enqueue the common initial responses, so future format/packing changes only need to be updated in one place.