RsMxo 2.6.0__py3-none-any.whl

RsMxo/CustomFiles/__init__.py

@@ -0,0 +1 @@
+"""Fixed files that are common for the Instrument drivers and the RsInstrument module."""

RsMxo/CustomFiles/events.py

@@ -0,0 +1,89 @@
+"""Event-related methods and properties. Here you can set all the event handlers."""
+
+from typing import Callable
+
+from ..Internal import Core
+
+
+class Events:
+	"""Common Events class.
+	Event-related methods and properties. Here you can set all the event handlers."""
+	def __init__(self, core: Core):
+		self._core = core
+
+	@property
+	def io_events_include_data(self) -> bool:
+		"""Returns the current state of the io_events_include_data See the setter for more details."""
+		return self._core.io.io_events_include_data
+
+	@io_events_include_data.setter
+	def io_events_include_data(self, value: bool) -> None:
+		"""If True, the on_write and on_read events include also the transferred data.
+		Default value is False, to avoid handling potentially big data."""
+		self._core.io.io_events_include_data = value
+
+	@property
+	def before_write_handler(self) -> Callable:
+		"""Returns the handler of before_write events. \n
+		:return: current ``before_write_handler``"""
+		return self._core.io.before_write_handler
+
+	@before_write_handler.setter
+	def before_write_handler(self, handler: Callable) -> None:
+		"""Sets handler for before_write events.
+		The before_write event is invoked before each write operation (only once, not for every chunk)
+		Event prototype: handler(io: Instrument, cmd: str)
+		:param handler: new handler"""
+		self._core.io.before_write_handler = handler
+
+	@property
+	def on_write_handler(self) -> Callable:
+		"""Returns the handler of on_write events. \n
+		:return: current ``on_write_handler``"""
+		return self._core.io.on_write_handler
+
+	@on_write_handler.setter
+	def on_write_handler(self, handler: Callable) -> None:
+		"""Sets handler for on_write events.
+		The on_write event is invoked every time the driver performs a write operation to the instrument (for each write chunk)
+		Event arguments type: IoTransferEventArgs
+		By default, the event_args do not contain the actual data sent. If you wish to receive them, set the driver.Events.io_events_include_data to True \n
+		:param handler: new handler for all write operations"""
+		self._core.io.on_write_handler = handler
+
+	@property
+	def on_read_handler(self) -> Callable:
+		"""Returns the handler of on_read events. \n
+		:return: current ``on_read_handler``"""
+		return self._core.io.on_read_handler
+
+	@on_read_handler.setter
+	def on_read_handler(self, handler: Callable) -> None:
+		"""Sets handler for on_read events.
+		The on_read event is invoked every time the driver performs a read operation to the instrument.
+		Event arguments type: IoTransferEventArgs
+		By default, the event_args do not contain the actual data sent. If you wish to receive them, set the driver.Events.io_events_include_data to True \n
+		:param handler: new handler for all read operations"""
+		self._core.io.on_read_handler = handler
+
+	@property
+	def before_query_handler(self) -> Callable:
+		"""Returns the handler of before_query events. \n
+		:return: current ``before_query_handler``"""
+		return self._core.io.before_query_handler
+
+	@before_query_handler.setter
+	def before_query_handler(self, handler: Callable) -> None:
+		"""Sets handler for before_query events.
+		The before_query event is invoked before each query operation (only once, not for every chunk)
+		Event prototype: handler(io: Instrument, query: str)
+		:param handler: new handler"""
+		self._core.io.before_query_handler = handler
+
+	def sync_from(self, source: 'Events') -> None:
+		"""Synchronises these Events with the source."""
+		self.before_query_handler = source.before_query_handler
+		self.before_write_handler = source.before_write_handler
+		self.io_events_include_data = source.io_events_include_data
+		self.on_read_handler = source.on_read_handler
+		self.on_write_handler = source.on_write_handler

RsMxo/CustomFiles/utilities.py

@@ -0,0 +1,533 @@
+"""Utilities extending the driver for methods provided with RsInstrument."""
+
+from typing import List, Tuple
+import threading
+
+from ..Internal import Core
+from ..Internal.ContextManagers import InstrErrorSuppressor, VisaTimeoutSuppressor
+from ..Internal import Conversions as Conv
+from ..Internal.ScpiLogger import ScpiLogger
+
+
+class Utilities:
+	"""Common utility class.
+	Utility functions common for all types of drivers. \n
+	Access snippet: ``utils = RsMxo.utilities``"""
+	def __init__(self, core: Core):
+		self._core = core
+
+	@property
+	def logger(self) -> ScpiLogger:
+		"""Scpi Logger interface, see :ref:`here <Logger>` \n
+		Access snippet: ``logger = RsMxo.utilities.logger``"""
+		return self._core.io.logger
+
+	@property
+	def driver_version(self) -> str:
+		"""Returns the instrument driver version."""
+		return self._core.driver_version
+
+	@property
+	def idn_string(self) -> str:
+		"""Returns instrument's identification string - the response on the SCPI command *IDN?"""
+		return self._core.io.idn_string
+
+	@property
+	def manufacturer(self) -> str:
+		"""Returns manufacturer of the instrument."""
+		return self._core.io.manufacturer
+
+	@property
+	def full_instrument_model_name(self) -> str:
+		"""Returns the current instrument's full name e.g. 'FSW26'."""
+		return self._core.io.full_model_name
+
+	@property
+	def instrument_model_name(self) -> str:
+		"""Returns the current instrument's family name e.g. 'FSW'."""
+		return self._core.io.model
+
+	@property
+	def supported_models(self) -> List[str]:
+		"""Returns a list of the instrument models supported by this instrument driver."""
+		return self._core.supported_instr_models
+
+	@property
+	def instrument_firmware_version(self) -> str:
+		"""Returns instrument's firmware version."""
+		return self._core.io.firmware_version
+
+	@property
+	def instrument_serial_number(self) -> str:
+		"""Returns instrument's serial_number."""
+		return self._core.io.serial_number
+
+	def query_opc(self, timeout: int = 0) -> int:
+		"""SCPI command: *OPC?
+		Queries the instrument's OPC bit and hence it waits until the instrument reports operation complete.
+		If you define timeout > 0, the VISA timeout is set to that value just for this method call."""
+		return self._core.io.query_opc(timeout)
+
+	@property
+	def instrument_status_checking(self) -> bool:
+		"""Sets / returns Instrument Status Checking.
+		When True (default is True), all the driver methods and properties are sending "SYSTem:ERRor?"
+		at the end to immediately react on error that might have occurred.
+		We recommend to keep the state checking ON all the time. Switch it OFF only in rare cases when you require maximum speed.
+		The default state after initializing the session is ON."""
+		return self._core.io.query_instr_status
+
+	@instrument_status_checking.setter
+	def instrument_status_checking(self, value) -> None:
+		"""Sets / returns Instrument Status Checking.
+		When True (default is True), all the driver methods and properties are sending "SYSTem:ERRor?"
+		at the end to immediately react on error that might have occurred.
+		We recommend to keep the state checking ON all the time. Switch it OFF only in rare cases when you require maximum speed.
+		The default state after initializing the session is ON."""
+		self._core.io.query_instr_status = value
+
+	@property
+	def encoding(self) -> str:
+		"""Returns string<=>bytes encoding of the session."""
+		return self._core.io.encoding
+
+	@encoding.setter
+	def encoding(self, value: str) -> None:
+		"""Sets string<=>bytes encoding of the session."""
+		self._core.io.encoding = value
+
+	@property
+	def opc_query_after_write(self) -> bool:
+		"""Sets / returns Instrument *OPC? query sending after each command write.
+		When True, (default is False) the driver sends *OPC? every time a write command is performed.
+		Use this if you want to make sure your sequence is performed command-after-command."""
+		return self._core.io.opc_query_after_write
+
+	@opc_query_after_write.setter
+	def opc_query_after_write(self, value) -> None:
+		"""Sets / returns Instrument *OPC? query sending after each command write.
+		When True, (default is False) the driver sends *OPC? every time a write command is performed.
+		Use this if you want to make sure your sequence is performed command-after-command."""
+		self._core.io.opc_query_after_write = value
+
+	@property
+	def bin_float_numbers_format(self) -> Conv.BinFloatFormat:
+		"""Sets / returns format of float numbers when transferred as binary data."""
+		return self._core.io.bin_float_numbers_format
+
+	@bin_float_numbers_format.setter
+	def bin_float_numbers_format(self, value: Conv.BinFloatFormat) -> None:
+		"""Sets / returns format of float numbers when transferred as binary data."""
+		self._core.io.bin_float_numbers_format = value
+
+	@property
+	def bin_int_numbers_format(self) -> Conv.BinIntFormat:
+		"""Sets / returns format of integer numbers when transferred as binary data."""
+		return self._core.io.bin_int_numbers_format
+
+	@bin_int_numbers_format.setter
+	def bin_int_numbers_format(self, value: Conv.BinIntFormat) -> None:
+		"""Sets / returns format of integer numbers when transferred as binary data."""
+		self._core.io.bin_int_numbers_format = value
+
+	def clear_status(self) -> None:
+		"""Clears instrument's status system, the session's I/O buffers and the instrument's error queue."""
+		return self._core.io.clear_status()
+
+	def query_all_errors(self) -> List[str] or None:
+		"""Queries and clears all the errors from the instrument's error queue.
+		The method returns list of strings as error messages. If no error is detected, the return value is None.
+		The process is: querying 'SYSTem:ERRor?' in a loop until the error queue is empty.
+		If you want to include the error codes, call the query_all_errors_with_codes()"""
+		return self._core.io.query_all_syst_errors(include_codes=False)
+
+	def query_all_errors_with_codes(self) -> List[Tuple[int, str]] or None:
+		"""Queries and clears all the errors from the instrument's error queue.
+		The method returns list of tuples (code: int, message: str). If no error is detected, the return value is None.
+		The process is: querying 'SYSTem:ERRor?' in a loop until the error queue is empty."""
+		return self._core.io.query_all_syst_errors(include_codes=True)
+
+	def reset(self) -> None:
+		"""SCPI command: *RST
+		Sends *RST command + calls the clear_status()."""
+		self._core.io.reset()
+		self.default_instrument_setup()
+
+	def default_instrument_setup(self) -> None:
+		"""Custom steps performed at the init and at the reset()."""
+
+	def self_test(self, timeout: int = None) -> Tuple[int, str]:
+		"""SCPI command: *TST?
+		Performs instrument's self-test.
+		Returns tuple (code:int, message: str). Code 0 means the self-test passed.
+		You can define the custom timeout in milliseconds. If you do not define it, the default selftest timeout is used (usually 60 secs)."""
+		return self._core.io.self_test(timeout)
+
+	def is_connection_active(self) -> bool:
+		"""Returns true, if the VISA connection is active and the communication with the instrument still works."""
+		return self._core.io.is_connection_active()
+
+	def reconnect(self, force_close: bool = False) -> bool:
+		"""If the connection is not active, the method tries to reconnect to the device
+		If the connection is active, and force_close is False, the method does nothing.
+		If the connection is active, and force_close is True, the method closes, and opens the session again.
+		Returns True, if the reconnection has been performed."""
+		return self._core.io.reconnect(force_close)
+
+	@property
+	def resource_name(self) -> int:
+		"""Returns the resource name used in the constructor"""
+		return self._core.io.resource_name
+
+	@property
+	def opc_timeout(self) -> int:
+		"""Sets / returns timeout in milliseconds for all the operations that use OPC synchronization."""
+		return self._core.io.opc_timeout
+
+	@opc_timeout.setter
+	def opc_timeout(self, value: int) -> None:
+		"""Sets / returns timeout in milliseconds for all the operations that use OPC synchronization."""
+		self._core.io.opc_timeout = value
+
+	@property
+	def visa_timeout(self) -> int:
+		"""Sets / returns visa IO timeout in milliseconds."""
+		return self._core.io.visa_timeout
+
+	@visa_timeout.setter
+	def visa_timeout(self, value) -> None:
+		"""Sets / returns visa IO timeout in milliseconds."""
+		self._core.io.visa_timeout = value
+
+	@property
+	def data_chunk_size(self) -> int:
+		"""Sets / returns the maximum size of one block transferred during write/read operations"""
+		return self._core.io.data_chunk_size
+
+	@data_chunk_size.setter
+	def data_chunk_size(self, chunk_size: int) -> None:
+		"""Sets / returns the maximum size of one block transferred during write/read operations."""
+		self._core.io.data_chunk_size = chunk_size
+
+	@property
+	def visa_manufacturer(self) -> int:
+		"""Returns the manufacturer of the current VISA session."""
+		return self._core.io.visa_manufacturer
+
+	def process_all_commands(self) -> None:
+		"""SCPI command: *WAI
+		Stops further commands processing until all commands sent before *WAI have been executed."""
+		return self._core.io.write('*WAI')
+
+	def write_str(self, cmd: str) -> None:
+		"""Writes the command to the instrument."""
+		self._core.io.write(cmd)
+
+	def write(self, cmd: str) -> None:
+		"""This method is an alias to the write_str().
+		Writes the command to the instrument as string."""
+		self._core.io.write(cmd)
+
+	def write_int(self, cmd: str, param: int) -> None:
+		"""Writes the command to the instrument followed by the integer parameter:
+		e.g.: cmd = 'SELECT:INPUT' param = '2', result command = 'SELECT:INPUT 2'"""
+		self._core.io.write(f'{cmd} {param}')
+
+	def write_int_with_opc(self, cmd: str, param: int, timeout: int = None) -> None:
+		"""Writes the command with OPC to the instrument followed by the integer parameter:
+		e.g.: cmd = 'SELECT:INPUT' param = '2', result command = 'SELECT:INPUT 2'
+		If you do not provide timeout, the method uses current opc_timeout."""
+		self._core.io.write_with_opc(f'{cmd} {param}', timeout)
+
+	def write_float(self, cmd: str, param: float) -> None:
+		"""Writes the command to the instrument followed by the boolean parameter:
+		e.g.: cmd = 'CENTER:FREQ' param = '10E6', result command = 'CENTER:FREQ 10E6'"""
+		self._core.io.write(f'{cmd} {Conv.float_to_str(param)}')
+
+	def write_float_with_opc(self, cmd: str, param: float, timeout: int = None) -> None:
+		"""Writes the command with OPC to the instrument followed by the boolean parameter:
+		e.g.: cmd = 'CENTER:FREQ' param = '10E6', result command = 'CENTER:FREQ 10E6'
+		If you do not provide timeout, the method uses current opc_timeout."""
+		self._core.io.write_with_opc(f'{cmd} {Conv.float_to_str(param)}', timeout)
+
+	def write_bool(self, cmd: str, param: bool) -> None:
+		"""Writes the command to the instrument followed by the boolean parameter:
+		e.g.: cmd = 'OUTPUT' param = 'True', result command = 'OUTPUT ON'"""
+		self._core.io.write(f'{cmd} {Conv.bool_to_str(param)}')
+
+	def write_bool_with_opc(self, cmd: str, param: bool, timeout: int = None) -> None:
+		"""Writes the command with OPC to the instrument followed by the boolean parameter:
+		e.g.: cmd = 'OUTPUT' param = 'True', result command = 'OUTPUT ON'
+		If you do not provide timeout, the method uses current opc_timeout."""
+		self._core.io.write_with_opc(f'{cmd} {Conv.bool_to_str(param)}', timeout)
+
+	def query_str(self, query: str) -> str:
+		"""Sends the query to the instrument and returns the response as string.
+		The response is trimmed of any trailing LF characters and has no length limit."""
+		return self._core.io.query_str(query)
+
+	def query(self, query: str) -> str:
+		"""This method is an alias to the query_str().
+		Sends the query to the instrument and returns the response as string.
+		The response is trimmed of any trailing LF characters and has no length limit."""
+		return self._core.io.query_str(query)
+
+	def query_bool(self, query: str) -> bool:
+		"""Sends the query to the instrument and returns the response as boolean."""
+		return self._core.io.query_bool(query)
+
+	def query_int(self, query: str) -> int:
+		"""Sends the query to the instrument and returns the response as integer."""
+		return self._core.io.query_int(query)
+
+	def query_float(self, query: str) -> float:
+		"""Sends the query to the instrument and returns the response as float."""
+		return self._core.io.query_float(query)
+
+	def write_str_with_opc(self, cmd: str, timeout: int = None) -> None:
+		"""Writes the opc-synced command to the instrument.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		self._core.io.write_with_opc(cmd, timeout)
+
+	def write_with_opc(self, cmd: str, timeout: int = None) -> None:
+		"""This method is an alias to the write_str_with_opc().
+		Writes the opc-synced command to the instrument.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		self._core.io.write_with_opc(cmd, timeout)
+
+	def query_str_with_opc(self, query: str, timeout: int = None) -> str:
+		"""Sends the opc-synced query to the instrument and returns the response as string.
+		The response is trimmed of any trailing LF characters and has no length limit.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_str_with_opc(query, timeout)
+
+	def query_with_opc(self, query: str, timeout: int = None) -> str:
+		"""This method is an alias to the query_str_with_opc().
+		Sends the opc-synced query to the instrument and returns the response as string.
+		The response is trimmed of any trailing LF characters and has no length limit.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_str_with_opc(query, timeout)
+
+	def query_bool_with_opc(self, query: str, timeout: int = None) -> bool:
+		"""Sends the opc-synced query to the instrument and returns the response as boolean.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_bool_with_opc(query, timeout)
+
+	def query_int_with_opc(self, query: str, timeout: int = None) -> int:
+		"""Sends the opc-synced query to the instrument and returns the response as integer.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_int_with_opc(query, timeout)
+
+	def query_float_with_opc(self, query: str, timeout: int = None) -> float:
+		"""Sends the opc-synced query to the instrument and returns the response as float.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_float_with_opc(query, timeout)
+
+	def write_bin_block(self, cmd: str, payload: bytes) -> None:
+		"""Writes all the payload as binary data block to the instrument.
+		The binary data header is added at the beginning of the transmission automatically, do not include it in the payload!!!"""
+		self._core.io.write_bin_block(cmd, payload)
+
+	def query_bin_block(self, query: str) -> bytes:
+		"""Queries binary data block to bytes.
+		Throws an exception if the returned data was not a binary data.
+		Returns data:bytes"""
+		return self._core.io.query_bin_block(query)
+
+	def query_bin_block_with_opc(self, query: str, timeout: int = None) -> bytes:
+		"""Sends a OPC-synced query and returns binary data block to bytes.
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_bin_block_with_opc(query, timeout)
+
+	def query_str_list(self, query: str, remove_blank_response: bool = False) -> List[str]:
+		"""Sends the string query to the instrument and returns the response as List of strings, where the delimiter is comma (',').
+		Each element of the list is trimmed for leading and trailing quotes.
+		Meaning of the 'remove_blank_response':
+			- False(default): whitespaces-only response is returned as a list with one empty element [''].
+			- True: whitespaces-only response is returned as an empty list []."""
+		return self._core.io.query_str_list(query, remove_blank_response)
+
+	def query_str_list_with_opc(self, query: str, timeout: int = None, remove_blank_response: bool = False) -> List[str]:
+		"""Sends a OPC-synced query and reads response from the instrument as csv-list.
+		If you do not provide timeout, the method uses current opc_timeout.
+		Meaning of the 'remove_blank_response':
+			- False(default): whitespaces-only response is returned as a list with one empty element [''].
+			- True: whitespaces-only response is returned as an empty list []."""
+		return self._core.io.query_str_list_with_opc(query, timeout, remove_blank_response)
+
+	def query_bool_list(self, query: str) -> List[bool]:
+		"""Sends the string query to the instrument and returns the response as List of booleans,
+		where the delimiter is comma (',').
+		Blank or empty response is returned as an empty list."""
+		return self._core.io.query_bool_list(query)
+
+	def query_bool_list_with_opc(self, query: str, timeout: int = None) -> List[bool]:
+		"""Sends a OPC-synced query and reads response from the instrument as csv-list of booleans.
+		If you do not provide timeout, the method uses current opc_timeout.
+		Blank or empty response is returned as an empty list."""
+		return self._core.io.query_bool_list_with_opc(query, timeout)
+
+	def query_bin_or_ascii_float_list(self, query: str) -> List[float]:
+		"""Queries a list of floating-point numbers that can be returned in ASCII format or in binary format.
+		- For ASCII format, the list numbers are decoded as comma-separated values.
+		- For Binary Format, the numbers are decoded based on the property BinFloatFormat, usually float 32-bit (FORM REAL,32)."""
+		return self._core.io.query_bin_or_ascii_float_list(query)
+
+	def query_bin_or_ascii_float_list_with_opc(self, query: str, timeout: int = None) -> List[float]:
+		"""Sends a OPC-synced query and reads a list of floating-point numbers that can be returned in ASCII format or in binary format.
+		- For ASCII format, the list numbers are decoded as comma-separated values.
+		- For Binary Format, the numbers are decoded based on the property BinFloatFormat, usually float 32-bit (FORM REAL,32).
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_bin_or_ascii_float_list_with_opc(query, timeout)
+
+	def query_bin_or_ascii_int_list(self, query: str) -> List[int]:
+		"""Queries a list of floating-point numbers that can be returned in ASCII format or in binary format.
+		- For ASCII format, the list numbers are decoded as comma-separated values.
+		- For Binary Format, the numbers are decoded based on the property BinFloatFormat, usually float 32-bit (FORM REAL,32)."""
+		return self._core.io.query_bin_or_ascii_int_list(query)
+
+	def query_bin_or_ascii_int_list_with_opc(self, query: str, timeout: int = None) -> List[int]:
+		"""Sends a OPC-synced query and reads a list of floating-point numbers that can be returned in ASCII format or in binary format.
+		- For ASCII format, the list numbers are decoded as comma-separated values.
+		- For Binary Format, the numbers are decoded based on the property BinFloatFormat, usually float 32-bit (FORM REAL,32).
+		If you do not provide timeout, the method uses current opc_timeout."""
+		return self._core.io.query_bin_or_ascii_int_list_with_opc(query, timeout)
+
+	# Write / Read to file
+	def query_bin_block_to_file(self, query: str, file_path: str, append: bool = False) -> None:
+		"""Queries binary data block to the provided file.
+		If append is False, any existing file content is discarded.
+		If append is True, the new content is added to the end of the existing file, or if the file does not exit, it is created.
+		Throws an exception if the returned data was not a binary data.
+		Example for transferring a file from Instrument -> PC:
+		query = f"MMEM:DATA? '{INSTR_FILE_PATH}'".
+		Alternatively, use the dedicated methods for this purpose:
+			- ``send_file_from_pc_to_instrument()``
+			- ``read_file_from_instrument_to_pc()``"""
+		self._core.io.query_bin_block_to_file(query, file_path, append)
+
+	def query_bin_block_to_file_with_opc(self, query: str, file_path: str, append: bool = False, timeout: int = None) -> None:
+		"""Sends a OPC-synced query and writes the returned data to the provided file.
+		If append is False, any existing file content is discarded.
+		If append is True, the new content is added to the end of the existing file, or if the file does not exit, it is created.
+		Throws an exception if the returned data was not a binary data."""
+		self._core.io.query_bin_block_to_file_with_opc(query, file_path, append, timeout)
+
+	def write_bin_block_from_file(self, cmd: str, file_path: str) -> None:
+		"""Writes data from the file as binary data block to the instrument using the provided command.
+		Example for transferring a file from PC -> Instrument:
+		cmd = f"MMEM:DATA '{INSTR_FILE_PATH}',".
+		Alternatively, use the dedicated methods for this purpose:
+			- ``send_file_from_pc_to_instrument()``
+			- ``read_file_from_instrument_to_pc()``"""
+		self._core.io.write_bin_block_from_file(cmd, file_path)
+
+	def send_file_from_pc_to_instrument(self, source_pc_file: str, target_instr_file: str) -> None:
+		"""SCPI Command: MMEM:DATA \n
+		Sends file from PC to the instrument"""
+		self._core.io.send_file_from_pc_to_instrument(source_pc_file, target_instr_file)
+
+	def read_file_from_instrument_to_pc(self, source_instr_file: str, target_pc_file: str, append_to_pc_file: bool = False) -> None:
+		"""SCPI Command: MMEM:DATA? \n
+		Reads file from instrument to the PC. \n
+		Set the ``append_to_pc_file`` to True if you want to append the read content to the end of the existing PC file"""
+		self._core.io.read_file_from_instrument_to_pc(source_instr_file, target_pc_file, append_to_pc_file)
+
+	def get_last_sent_cmd(self) -> str:
+		"""Returns the last commands sent to the instrument. Only works in simulation mode"""
+		return self._core.get_last_sent_cmd()
+
+	def go_to_local(self) -> None:
+		"""Puts the instrument into local state."""
+		self._core.io.go_to_local()
+
+	def go_to_remote(self) -> None:
+		"""Puts the instrument into remote state."""
+		self._core.io.go_to_remote()
+
+	def get_lock(self) -> threading.RLock:
+		"""Returns the thread lock for the current session. \n
+		By default:
+			- If you create standard new RsMxo instance with new VISA session, the session gets a new thread lock. You can assign it to other RsMxo sessions in order to share one physical instrument with a multi-thread access.
+			- If you create new RsMxo from an existing session, the thread lock is shared automatically making both instances multi-thread safe.
+		You can always assign new thread lock by calling ``driver.utilities.assign_lock()``"""
+		return self._core.io.get_lock()
+
+	def assign_lock(self, lock: threading.RLock) -> None:
+		"""Assigns the provided thread lock."""
+		self._core.io.assign_lock(lock)
+
+	def clear_lock(self):
+		"""Clears the existing thread lock, making the current session thread-independent from others that might share the current thread lock."""
+		self._core.io.clear_lock()
+
+	def instr_err_suppressor(self, visa_tout_ms: int = 0, suppress_only_codes: int or List[int] = None) -> InstrErrorSuppressor:
+		"""Returns Context Manager that suppresses the instrument errors.
+		Other exceptions types are still raised.
+		On entering the context, this class clears all the instrument status errors.
+		:param visa_tout_ms: VISA Timeout in milliseconds, that is set for this context. Afterward, it is changed back. Default value: do-not-change.
+		:param suppress_only_codes: You can enter a code or list of codes for errors to be suppressed. Other errors will be reported. Example: If you enter -113 here, only the 'Undefined Header' error will be suppressed. Default value: suppress-all-errors."""
+		return InstrErrorSuppressor(self._core.io, visa_tout_ms, suppress_only_codes)
+
+	def visa_tout_suppressor(self, visa_tout_ms: int = 0) -> VisaTimeoutSuppressor:
+		"""Returns Context Manager that suppresses the VISA timeout error.
+		Careful!!!: Only the very first VISA Timeout exception is suppressed,
+		and afterward the context ends. Therefore, use only one command per context manager,
+		if you do not want to skip the following ones.
+		:param visa_tout_ms: VISA Timeout in milliseconds, that is set for this context. Afterward, it is changed back. Default value: do-not-change.
+		"""
+		return VisaTimeoutSuppressor(self._core.io, visa_tout_ms)
+
+	def sync_from(self, source: 'Utilities') -> None:
+		"""Synchronises these Utils with the source."""
+		self.logger.sync_from(source.logger)
+		self.assign_lock(source.get_lock())
+		self.bin_float_numbers_format = source.bin_float_numbers_format
+		self.bin_int_numbers_format = source.bin_int_numbers_format
+		self.data_chunk_size = source.data_chunk_size
+		self.encoding = source.encoding
+		self.instrument_status_checking = source.instrument_status_checking
+		self.opc_query_after_write = source.opc_query_after_write
+		self.opc_timeout = source.opc_timeout
+
+	@property
+	def instrument_options(self) -> List[str]:
+		"""Returns all the instrument options.
+		The options are sorted in the ascending order starting with K-options and continuing with B-options."""
+		return self._core.io.instr_options.get_all()
+
+	def has_instr_option(self, options: str or List[str]) -> bool:
+		"""Returns true, if the entered options (case-insensitive) matches at least one of the installed options (or-logic).
+		You can enter either a string with one option, or more options '/'-separated, or more options as a list of strings.
+		If K0 is present, all the K-options are reported as present. B-options are not affected by K0.
+		Example 1: options='k23' returns true, if the instrument has the option 'K23'.
+		Example 2: options='k23 / K23e' returns true, if the instrument has either the option 'K23' or the option 'K23E'.
+		Example 3: options=['k11','K22'] returns true, if the instrument has either the option 'K11' or the option 'K22'."""
+		return self._core.io.instr_options.has(options)
+
+	def has_instr_option_regex(self, re_options: str or List[str]) -> bool:
+		"""Returns true, if the entered regex string (case-insensitive) matches at least one of the installed options.
+		The match must be complete, not just partial (search).
+		You can enter either a string with one option, or more options '/'-separated, or more options as a list of strings.
+		Example 1: re_options='k10.' returns true, if the instrument contains any option 'K100' ... up to 'K109' .
+		Example 2: re_options='k10. / k20.*' returns true, if the instrument contains any of the options 'K10x' or 'K20xxx'.
+		Example 3: re_options=['k10.', 'k20.*'] returns true, if the instrument contains any options 'K10x' or 'K20xxx'."""
+		return self._core.io.instr_options.has_regex(re_options)
+
+	def has_instr_option_k0(self) -> bool:
+		"""Returns true, if the instrument has K0 installed."""
+		return self._core.io.instr_options.has_k0()
+
+	def add_instr_option(self, option: str) -> None:
+		"""Adds new option if not already existing."""
+		self._core.io.instr_options.add(option)
+
+	def remove_instr_option(self, option: str) -> None:
+		"""Removes the option if exists."""
+		self._core.io.instr_options.remove(option)
+
+	def check_status(self) -> None:
+		"""Throws InstrumentStatusException in case of an error in the instrument's error queue.
+		The status checking is performed always, independent of the property 'instrument_status_checking'.
+		Also, the property ScpiLogger.log_status_check_ok is ignored, and the Status check is always logged."""
+		self._core.io.check_status_always(True)

RsMxo/Implementations/Acquire/History/Play.py

@@ -0,0 +1,26 @@
+from ....Internal.Core import Core
+from ....Internal.CommandsGroup import CommandsGroup
+
+
+# noinspection PyPep8Naming,PyAttributeOutsideInit,SpellCheckingInspection
+class PlayCls:
+	"""Play commands group definition. 1 total commands, 0 Subgroups, 1 group commands"""
+
+	def __init__(self, core: Core, parent):
+		self._core = core
+		self._cmd_group = CommandsGroup("play", core, parent)
+
+	def set(self) -> None:
+		"""SCPI: ACQuire:HISTory:PLAY \n
+		Snippet: driver.acquire.history.play.set() \n
+		Starts and stops the replay of the history waveforms. \n
+		"""
+		self._core.io.write(f'ACQuire:HISTory:PLAY')
+
+	def set_and_wait(self, opc_timeout_ms: int = -1) -> None:
+		"""SCPI: ACQuire:HISTory:PLAY \n
+		Snippet: driver.acquire.history.play.set_with_opc() \n
+		Starts and stops the replay of the history waveforms. \n
+		Same as set, but waits for the operation to complete before continuing further. Use the RsMxo.utilities.opc_timeout_set() to set the timeout value. \n
+			:param opc_timeout_ms: Maximum time to wait in milliseconds, valid only for this call."""
+		self._core.io.write_with_opc(f'ACQuire:HISTory:PLAY', opc_timeout_ms)