nirfmxvna 26.3.0__py3-none-any.whl

nirfmxvna/internal/_grpc_stub_interpreter.py

@@ -0,0 +1,1757 @@
+"""Interpreter for interacting with a gRPC Stub class."""
+
+import ctypes
+import importlib
+import os
+import sys
+import threading
+import warnings
+
+import grpc
+import numpy
+
+current_file = __file__
+absolute_path = os.path.abspath(current_file)
+directory = os.path.dirname(absolute_path)
+sys.path.append(directory)
+import nirfmxinstr
+import nirfmxvna.enums as enums
+import nirfmxvna.errors as errors
+import nirfmxvna.internal._custom_types as _custom_types
+import nirfmxvna.internal._helper as _helper
+import nirfmxvna.internal.nirfmxvna_pb2 as grpc_types
+import nirfmxvna.internal.nirfmxvna_pb2_grpc as nirfmxvna_grpc
+from google.protobuf import descriptor_pool as _descriptor_pool
+
+
+def _import_pb2_once(proto_file, qualified_name, bare_name):
+    """Import a generated pb2 module, or reuse one already in the descriptor pool.
+
+    All nirfmx packages bundle identical copies of session_pb2 and nidevice_pb2.
+    On protobuf >= 4.x, importing a second copy calls AddSerializedFile again
+    with the same .proto filename, which raises an error.  Avoid this by checking
+    the pool first: if the proto is already registered, look up the module that
+    registered it and alias it under both the qualified and bare names so that
+    downstream imports (including the bare ``import session_pb2`` done by
+    generated *_pb2.py code) all resolve to the single, already-registered module.
+    """
+    try:
+        _descriptor_pool.Default().FindFileByName(proto_file)
+    except KeyError:
+        # Not yet registered — import ours, which will call AddSerializedFile.
+        mod = importlib.import_module(qualified_name)
+        sys.modules.setdefault(bare_name, mod)
+        return mod
+
+    # Already registered by another package — reuse the existing module.
+    mod = sys.modules.get(bare_name) or next(  # type: ignore
+        (
+            m
+            for n, m in sys.modules.items()
+            if n.endswith("." + bare_name) and hasattr(m, "DESCRIPTOR")
+        ),
+        None,
+    )
+    if mod is None:
+        # Pool has it but no module found (should not happen) — import anyway.
+        mod = importlib.import_module(qualified_name)
+    sys.modules.setdefault(bare_name, mod)
+    sys.modules.setdefault(qualified_name, mod)
+    return mod
+
+
+session_grpc_types = _import_pb2_once("session.proto", "nirfmxvna.internal.session_pb2", "session_pb2")  # type: ignore
+nidevice_grpc_types = _import_pb2_once("nidevice.proto", "nirfmxvna.internal.nidevice_pb2", "nidevice_pb2")  # type: ignore
+
+
+class GrpcStubInterpreter(object):
+    """Interpreter for interacting with a gRPC Stub class"""
+
+    def __init__(self, grpc_options, session=None, signal_obj=None):
+        self._grpc_options = grpc_options
+        self._signal_obj = signal_obj
+        self._instr_session = session
+        self._client = nirfmxvna_grpc.NiRFmxVNAStub(grpc_options.grpc_channel)  # type: ignore
+        self.set_session_handle()  # type: ignore
+
+    def set_session_handle(self, value=session_grpc_types.Session()):
+        self._vi = value
+
+    def get_session_handle(self):
+        return self._vi
+
+    def _invoke(self, func, request, metadata=None, ignore_driver_error=False):
+        response = None
+        try:
+            response = func(request, metadata=metadata)
+            error_code = response.status
+            error_message = ""
+        except grpc.RpcError as rpc_error:
+            error_code = None
+            error_message = rpc_error.details()
+            for entry in rpc_error.trailing_metadata() or []:
+                if entry.key == "ni-error":
+                    value = (
+                        entry.value if isinstance(entry.value, str) else entry.value.decode("utf-8")
+                    )
+                    try:
+                        error_code = int(value)
+                    except ValueError:
+                        error_message += f"\nError status: {value}"
+
+            grpc_error = rpc_error.code()
+            if grpc_error == grpc.StatusCode.NOT_FOUND:
+                raise errors.DriverTooOldError() from None  # type: ignore
+            elif grpc_error == grpc.StatusCode.INVALID_ARGUMENT:
+                raise ValueError(error_message) from None
+            elif grpc_error == grpc.StatusCode.UNAVAILABLE:
+                error_message = "Failed to connect to server"
+            elif grpc_error == grpc.StatusCode.UNIMPLEMENTED:
+                error_message = "This operation is not supported by the NI gRPC Device Server being used. Upgrade NI gRPC Device Server."
+
+            if error_code is None:
+                raise errors.RpcError(grpc_error, error_message) from None  # type: ignore
+
+        if error_code < 0 and not ignore_driver_error:
+            import nirfmxinstr
+
+            raise nirfmxinstr.RFmxError(error_code, error_message)  # type: ignore
+
+        return response
+
+    def get_error_string(self, error_code):
+        """Returns the error message."""
+        response = self._invoke(
+            self._client.GetErrorString,
+            grpc_types.GetErrorStringRequest(instrument=self._vi, error_code=error_code),  # type: ignore
+        )
+        return response.error_description
+
+    def get_error(self):
+        """Returns the error code and error message."""
+        response = self._invoke(
+            self._client.GetError, grpc_types.GetErrorRequest(instrument=self._vi)  # type: ignore
+        )
+        return response.error_code, response.error_description
+
+    def get_error_description(self, error_code):
+        """Returns the error description."""
+        try:
+            returned_error_code, error_string = self.get_error()  # type: ignore
+            if returned_error_code == error_code:
+                return error_string
+        except errors.Error:
+            pass
+
+        try:
+            """
+            It is expected for get_error to raise when the session is invalid
+            Use get_error_string instead. It doesn't require a session.
+            """
+            error_string = self.get_error_string(error_code)  # type: ignore
+            return error_string
+        except errors.Error:
+            pass
+        return "Failed to retrieve error description."
+
+    def reset_attribute(self, selector_string, attribute_id):
+        """reset_attribute."""
+        response = self._invoke(
+            self._client.ResetAttribute,
+            grpc_types.ResetAttributeRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.status
+
+    def check_if_current_signal_exists(self):
+        """check_if_current_signal_exists."""
+        return_value = False
+        if not self._signal_obj.signal_configuration_name:
+            signal_configuration_exists, local_personality, _ = (
+                self._signal_obj._rfmxinstrsession_interpreter.check_if_signal_exists(
+                    self._signal_obj._default_signal_name_user_visible
+                )
+            )
+            return_value = signal_configuration_exists and (
+                local_personality.value == nirfmxinstr.Personalities.VNA.value
+            )
+        else:
+            signal_configuration_exists, local_personality, _ = (
+                self._signal_obj._rfmxinstrsession_interpreter.check_if_signal_exists(
+                    self._signal_obj.signal_configuration_name
+                )
+            )
+            return_value = signal_configuration_exists and (
+                local_personality.value == nirfmxinstr.Personalities.VNA.value
+            )
+        return return_value
+
+    def get_attribute_i8(self, selector_string, attribute_id):
+        """get_attribute_i8."""
+        response = self._invoke(
+            self._client.GetAttributeI8,
+            grpc_types.GetAttributeI8Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i8(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i8."""
+        response = self._invoke(
+            self._client.SetAttributeI8,
+            grpc_types.SetAttributeI8Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i8_array(self, selector_string, attribute_id):
+        """get_attribute_i8_array."""
+        response = self._invoke(
+            self._client.GetAttributeI8Array,
+            grpc_types.GetAttributeI8ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i8_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i8_array."""
+        response = self._invoke(
+            self._client.SetAttributeI8Array,
+            grpc_types.SetAttributeI8ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i16(self, selector_string, attribute_id):
+        """get_attribute_i16."""
+        response = self._invoke(
+            self._client.GetAttributeI16,
+            grpc_types.GetAttributeI16Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i16(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i16."""
+        response = self._invoke(
+            self._client.SetAttributeI16,
+            grpc_types.SetAttributeI16Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i32(self, selector_string, attribute_id):
+        """get_attribute_i32."""
+        response = self._invoke(
+            self._client.GetAttributeI32,
+            grpc_types.GetAttributeI32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val_raw, response.status
+
+    def set_attribute_i32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i32."""
+        response = self._invoke(
+            self._client.SetAttributeI32,
+            grpc_types.SetAttributeI32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val_raw=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i32_array(self, selector_string, attribute_id):
+        """get_attribute_i32_array."""
+        response = self._invoke(
+            self._client.GetAttributeI32Array,
+            grpc_types.GetAttributeI32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i32_array."""
+        response = self._invoke(
+            self._client.SetAttributeI32Array,
+            grpc_types.SetAttributeI32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i64(self, selector_string, attribute_id):
+        """get_attribute_i64."""
+        response = self._invoke(
+            self._client.GetAttributeI64,
+            grpc_types.GetAttributeI64Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i64(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i64."""
+        response = self._invoke(
+            self._client.SetAttributeI64,
+            grpc_types.SetAttributeI64Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_i64_array(self, selector_string, attribute_id):
+        """get_attribute_i64_array."""
+        response = self._invoke(
+            self._client.GetAttributeI64Array,
+            grpc_types.GetAttributeI64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_i64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_i64_array."""
+        response = self._invoke(
+            self._client.SetAttributeI64Array,
+            grpc_types.SetAttributeI64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u8(self, selector_string, attribute_id):
+        """get_attribute_u8."""
+        response = self._invoke(
+            self._client.GetAttributeU8,
+            grpc_types.GetAttributeU8Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u8(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u8."""
+        response = self._invoke(
+            self._client.SetAttributeU8,
+            grpc_types.SetAttributeU8Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u8_array(self, selector_string, attribute_id):
+        """get_attribute_u8_array."""
+        response = self._invoke(
+            self._client.GetAttributeU8Array,
+            grpc_types.GetAttributeU8ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u8_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u8_array."""
+        response = self._invoke(
+            self._client.SetAttributeU8Array,
+            grpc_types.SetAttributeU8ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u16(self, selector_string, attribute_id):
+        """get_attribute_u16."""
+        response = self._invoke(
+            self._client.GetAttributeU16,
+            grpc_types.GetAttributeU16Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u16(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u16."""
+        response = self._invoke(
+            self._client.SetAttributeU16,
+            grpc_types.SetAttributeU16Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u32(self, selector_string, attribute_id):
+        """get_attribute_u32."""
+        response = self._invoke(
+            self._client.GetAttributeU32,
+            grpc_types.GetAttributeU32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u32."""
+        response = self._invoke(
+            self._client.SetAttributeU32,
+            grpc_types.SetAttributeU32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u32_array(self, selector_string, attribute_id):
+        """get_attribute_u32_array."""
+        response = self._invoke(
+            self._client.GetAttributeU32Array,
+            grpc_types.GetAttributeU32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u32_array."""
+        response = self._invoke(
+            self._client.SetAttributeU32Array,
+            grpc_types.SetAttributeU32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_u64_array(self, selector_string, attribute_id):
+        """get_attribute_u64_array."""
+        response = self._invoke(
+            self._client.GetAttributeU64Array,
+            grpc_types.GetAttributeU64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_u64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_u64_array."""
+        response = self._invoke(
+            self._client.SetAttributeU64Array,
+            grpc_types.SetAttributeU64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_f32(self, selector_string, attribute_id):
+        """get_attribute_f32."""
+        response = self._invoke(
+            self._client.GetAttributeF32,
+            grpc_types.GetAttributeF32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_f32(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f32."""
+        response = self._invoke(
+            self._client.SetAttributeF32,
+            grpc_types.SetAttributeF32Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_f32_array(self, selector_string, attribute_id):
+        """get_attribute_f32_array."""
+        response = self._invoke(
+            self._client.GetAttributeF32Array,
+            grpc_types.GetAttributeF32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_f32_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f32_array."""
+        response = self._invoke(
+            self._client.SetAttributeF32Array,
+            grpc_types.SetAttributeF32ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_f64(self, selector_string, attribute_id):
+        """get_attribute_f64."""
+        response = self._invoke(
+            self._client.GetAttributeF64,
+            grpc_types.GetAttributeF64Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_f64(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f64."""
+        response = self._invoke(
+            self._client.SetAttributeF64,
+            grpc_types.SetAttributeF64Request(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_f64_array(self, selector_string, attribute_id):
+        """get_attribute_f64_array."""
+        response = self._invoke(
+            self._client.GetAttributeF64Array,
+            grpc_types.GetAttributeF64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_f64_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_f64_array."""
+        response = self._invoke(
+            self._client.SetAttributeF64Array,
+            grpc_types.SetAttributeF64ArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_nicomplexsingle_array(self, selector_string, attribute_id):
+        """get_attribute_nicomplexsingle_array."""
+        response = self._invoke(
+            self._client.GetAttributeNIComplexSingleArray,
+            grpc_types.GetAttributeNIComplexSingleArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_nicomplexsingle_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_nicomplexsingle_array."""
+        response = self._invoke(
+            self._client.SetAttributeNIComplexSingleArray,
+            grpc_types.SetAttributeNIComplexSingleArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_nicomplexdouble_array(self, selector_string, attribute_id):
+        """get_attribute_nicomplexdouble_array."""
+        response = self._invoke(
+            self._client.GetAttributeNIComplexDoubleArray,
+            grpc_types.GetAttributeNIComplexDoubleArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_nicomplexdouble_array(self, selector_string, attribute_id, attr_val):
+        """set_attribute_nicomplexdouble_array."""
+        response = self._invoke(
+            self._client.SetAttributeNIComplexDoubleArray,
+            grpc_types.SetAttributeNIComplexDoubleArrayRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def get_attribute_string(self, selector_string, attribute_id):
+        """get_attribute_string."""
+        response = self._invoke(
+            self._client.GetAttributeString,
+            grpc_types.GetAttributeStringRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id),  # type: ignore
+        )
+        return response.attr_val, response.status
+
+    def set_attribute_string(self, selector_string, attribute_id, attr_val):
+        """set_attribute_string."""
+        response = self._invoke(
+            self._client.SetAttributeString,
+            grpc_types.SetAttributeStringRequest(instrument=self._vi, selector_string=selector_string, attribute_id=attribute_id, attr_val_raw=attr_val),  # type: ignore
+        )
+        return response.status
+
+    def s_params_configure_s_parameter(self, selector_string, s_parameter):
+        """s_params_configure_s_parameter."""
+        response = self._invoke(
+            self._client.SParamsCfgSParameter,
+            grpc_types.SParamsCfgSParameterRequest(instrument=self._vi, selector_string=selector_string, s_parameter=s_parameter),  # type: ignore
+        )
+        return response.status
+
+    def s_params_export_to_snp_file(self, selector_string, snp_file_path):
+        """s_params_export_to_snp_file."""
+        response = self._invoke(
+            self._client.SParamsExportToSnPFile,
+            grpc_types.SParamsExportToSnPFileRequest(instrument=self._vi, selector_string=selector_string, snp_file_path=snp_file_path),  # type: ignore
+        )
+        return response.status
+
+    def waves_configure_wave(self, selector_string, wave):
+        """waves_configure_wave."""
+        response = self._invoke(
+            self._client.WavesCfgWave,
+            grpc_types.WavesCfgWaveRequest(instrument=self._vi, selector_string=selector_string, wave=wave),  # type: ignore
+        )
+        return response.status
+
+    def abort_measurements(self, selector_string):
+        """abort_measurements."""
+        response = self._invoke(
+            self._client.AbortMeasurements,
+            grpc_types.AbortMeasurementsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def calibration_initiate(self, selector_string):
+        """calibration_initiate."""
+        response = self._invoke(
+            self._client.CalibrationInitiate,
+            grpc_types.CalibrationInitiateRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def calibration_acquire(self, selector_string, timeout):
+        """calibration_acquire."""
+        response = self._invoke(
+            self._client.CalibrationAcquire,
+            grpc_types.CalibrationAcquireRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.status
+
+    def calibration_abort(self, selector_string):
+        """calibration_abort."""
+        response = self._invoke(
+            self._client.CalibrationAbort,
+            grpc_types.CalibrationAbortRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def calibration_save(self, selector_string, calset_name):
+        """calibration_save."""
+        response = self._invoke(
+            self._client.CalibrationSave,
+            grpc_types.CalibrationSaveRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name),  # type: ignore
+        )
+        return response.status
+
+    def clear_calset(self, selector_string, calset_name):
+        """clear_calset."""
+        response = self._invoke(
+            self._client.ClearCalset,
+            grpc_types.ClearCalsetRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name),  # type: ignore
+        )
+        return response.status
+
+    def calset_load_from_file(self, selector_string, calset_name, calset_file_path):
+        """calset_load_from_file."""
+        response = self._invoke(
+            self._client.CalsetLoadFromFile,
+            grpc_types.CalsetLoadFromFileRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, calset_file_path=calset_file_path),  # type: ignore
+        )
+        return response.status
+
+    def calset_save_to_file(self, selector_string, calset_name, calset_file_path):
+        """calset_save_to_file."""
+        response = self._invoke(
+            self._client.CalsetSaveToFile,
+            grpc_types.CalsetSaveToFileRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, calset_file_path=calset_file_path),  # type: ignore
+        )
+        return response.status
+
+    def auto_detect_vcal_orientation(self, selector_string):
+        """auto_detect_vcal_orientation."""
+        response = self._invoke(
+            self._client.AutoDetectvCalOrientation,
+            grpc_types.AutoDetectvCalOrientationRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def check_measurement_status(self, selector_string):
+        """check_measurement_status."""
+        response = self._invoke(
+            self._client.CheckMeasurementStatus,
+            grpc_types.CheckMeasurementStatusRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return bool(response.is_done), response.status
+
+    def clear_all_named_results(self, selector_string):
+        """clear_all_named_results."""
+        response = self._invoke(
+            self._client.ClearAllNamedResults,
+            grpc_types.ClearAllNamedResultsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def clear_named_result(self, selector_string):
+        """clear_named_result."""
+        response = self._invoke(
+            self._client.ClearNamedResult,
+            grpc_types.ClearNamedResultRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def copy_calset(self, selector_string, source_calset_name, new_calset_name):
+        """copy_calset."""
+        response = self._invoke(
+            self._client.CopyCalset,
+            grpc_types.CopyCalsetRequest(instrument=self._vi, selector_string=selector_string, source_calset_name=source_calset_name, new_calset_name=new_calset_name),  # type: ignore
+        )
+        return response.status
+
+    def select_active_calset(self, selector_string, calset_name, restore_configuration):
+        """select_active_calset."""
+        response = self._invoke(
+            self._client.SelectActiveCalset,
+            grpc_types.SelectActiveCalsetRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, restore_configuration_raw=restore_configuration),  # type: ignore
+        )
+        return response.status
+
+    def get_all_calset_names(self, selector_string):
+        """get_all_calset_names."""
+        response = self._invoke(
+            self._client.GetAllCalsetNames,
+            grpc_types.GetAllCalsetNamesRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.calset_names, response.status
+
+    def commit(self, selector_string):
+        """commit."""
+        response = self._invoke(
+            self._client.Commit,
+            grpc_types.CommitRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def create_signal_configuration(self, signal_name):
+        """create_signal_configuration."""
+        response = self._invoke(
+            self._client.CreateSignalConfiguration,
+            grpc_types.CreateSignalConfigurationRequest(instrument=self._vi, signal_name=signal_name),  # type: ignore
+        )
+        return response.status
+
+    def initiate(self, selector_string, result_name):
+        """initiate."""
+        response = self._invoke(
+            self._client.Initiate,
+            grpc_types.InitiateRequest(instrument=self._vi, selector_string=selector_string, result_name=result_name),  # type: ignore
+        )
+        return response.status
+
+    def reset_to_default(self, selector_string):
+        """reset_to_default."""
+        response = self._invoke(
+            self._client.ResetToDefault,
+            grpc_types.ResetToDefaultRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def select_measurements(self, selector_string, measurements, enable_all_traces):
+        """select_measurements."""
+        response = self._invoke(
+            self._client.SelectMeasurements,
+            grpc_types.SelectMeasurementsRequest(instrument=self._vi, selector_string=selector_string, measurements_raw=measurements, enable_all_traces=enable_all_traces),  # type: ignore
+        )
+        return response.status
+
+    def wait_for_measurement_complete(self, selector_string, timeout):
+        """wait_for_measurement_complete."""
+        response = self._invoke(
+            self._client.WaitForMeasurementComplete,
+            grpc_types.WaitForMeasurementCompleteRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.status
+
+    def calset_embed_fixture_s2p(
+        self,
+        selector_string,
+        calset_name,
+        fixture_s2p_file_path,
+        vna_port,
+        s_parameter_orientation,
+        new_calset_name,
+    ):
+        """calset_embed_fixture_s2p."""
+        response = self._invoke(
+            self._client.CalsetEmbedFixtureS2p,
+            grpc_types.CalsetEmbedFixtureS2pRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, fixture_s2p_file_path=fixture_s2p_file_path, vna_port=vna_port, s_parameter_orientation_raw=s_parameter_orientation, new_calset_name=new_calset_name),  # type: ignore
+        )
+        return response.status
+
+    def deselect_active_calset(self, selector_string):
+        """deselect_active_calset."""
+        response = self._invoke(
+            self._client.DeselectActiveCalset,
+            grpc_types.DeselectActiveCalsetRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def load_data_to_measurement_memory_from_file(
+        self, selector_string, file_path, parameter, measurement_memory_name
+    ):
+        """load_data_to_measurement_memory_from_file."""
+        response = self._invoke(
+            self._client.LoadDataToMeasurementMemoryFromFile,
+            grpc_types.LoadDataToMeasurementMemoryFromFileRequest(instrument=self._vi, selector_string=selector_string, file_path=file_path, parameter=parameter, measurement_memory_name=measurement_memory_name),  # type: ignore
+        )
+        return response.status
+
+    def copy_data_to_measurement_memory(self, selector_string, measurement_memory_name):
+        """copy_data_to_measurement_memory."""
+        response = self._invoke(
+            self._client.CopyDataToMeasurementMemory,
+            grpc_types.CopyDataToMeasurementMemoryRequest(instrument=self._vi, selector_string=selector_string, measurement_memory_name=measurement_memory_name),  # type: ignore
+        )
+        return response.status
+
+    def get_measurement_memory_names(self, selector_string):
+        """get_measurement_memory_names."""
+        response = self._invoke(
+            self._client.GetMeasurementMemoryNames,
+            grpc_types.GetMeasurementMemoryNamesRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.measurement_memory_names, response.status
+
+    def clear_measurement_memory_names(self, selector_string):
+        """clear_measurement_memory_names."""
+        response = self._invoke(
+            self._client.ClearMeasurementMemoryNames,
+            grpc_types.ClearMeasurementMemoryNamesRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.status
+
+    def auto_port_extension_measure(self, selector_string, standard, port):
+        """auto_port_extension_measure."""
+        response = self._invoke(
+            self._client.AutoPortExtensionMeasure,
+            grpc_types.AutoPortExtensionMeasureRequest(instrument=self._vi, selector_string=selector_string, standard_raw=standard, port=port),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_import_calkit(self, selector_string, calkit_file_path):
+        """calkit_manager_import_calkit."""
+        response = self._invoke(
+            self._client.CalkitManagerImportCalkit,
+            grpc_types.CalkitManagerImportCalkitRequest(instrument=self._vi, selector_string=selector_string, calkit_file_path=calkit_file_path),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_export_calkit(self, selector_string, calkit_id, calkit_file_path):
+        """calkit_manager_export_calkit."""
+        response = self._invoke(
+            self._client.CalkitManagerExportCalkit,
+            grpc_types.CalkitManagerExportCalkitRequest(instrument=self._vi, selector_string=selector_string, calkit_id=calkit_id, calkit_file_path=calkit_file_path),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_create_calkit(self, selector_string, calkit_id):
+        """calkit_manager_create_calkit."""
+        response = self._invoke(
+            self._client.CalkitManagerCreateCalkit,
+            grpc_types.CalkitManagerCreateCalkitRequest(instrument=self._vi, selector_string=selector_string, calkit_id=calkit_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_remove_calkit(self, selector_string, calkit_id):
+        """calkit_manager_remove_calkit."""
+        response = self._invoke(
+            self._client.CalkitManagerRemoveCalkit,
+            grpc_types.CalkitManagerRemoveCalkitRequest(instrument=self._vi, selector_string=selector_string, calkit_id=calkit_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_validate_calkit(self, selector_string, calkit_id):
+        """calkit_manager_validate_calkit."""
+        response = self._invoke(
+            self._client.CalkitManagerValidateCalkit,
+            grpc_types.CalkitManagerValidateCalkitRequest(instrument=self._vi, selector_string=selector_string, calkit_id=calkit_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_get_calkit_ids(self, selector_string):
+        """calkit_manager_get_calkit_ids."""
+        response = self._invoke(
+            self._client.CalkitManagerGetCalkitIDs,
+            grpc_types.CalkitManagerGetCalkitIDsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.calkit_ids, response.status
+
+    def calkit_manager_calkit_add_connector(self, selector_string, connector_id):
+        """calkit_manager_calkit_add_connector."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitAddConnector,
+            grpc_types.CalkitManagerCalkitAddConnectorRequest(instrument=self._vi, selector_string=selector_string, connector_id=connector_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_remove_connector(self, selector_string, connector_id):
+        """calkit_manager_calkit_remove_connector."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitRemoveConnector,
+            grpc_types.CalkitManagerCalkitRemoveConnectorRequest(instrument=self._vi, selector_string=selector_string, connector_id=connector_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_get_connector_ids(self, selector_string):
+        """calkit_manager_calkit_get_connector_ids."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetConnectorIDs,
+            grpc_types.CalkitManagerCalkitGetConnectorIDsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.connector_ids, response.status
+
+    def calkit_manager_calkit_add_calibration_element(
+        self, selector_string, calibration_element_id
+    ):
+        """calkit_manager_calkit_add_calibration_element."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitAddCalibrationElement,
+            grpc_types.CalkitManagerCalkitAddCalibrationElementRequest(instrument=self._vi, selector_string=selector_string, calibration_element_id=calibration_element_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_remove_calibration_element(
+        self, selector_string, calibration_element_id
+    ):
+        """calkit_manager_calkit_remove_calibration_element."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitRemoveCalibrationElement,
+            grpc_types.CalkitManagerCalkitRemoveCalibrationElementRequest(instrument=self._vi, selector_string=selector_string, calibration_element_id=calibration_element_id),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_get_calibration_element_ids(self, selector_string):
+        """calkit_manager_calkit_get_calibration_element_ids."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetCalibrationElementIDs,
+            grpc_types.CalkitManagerCalkitGetCalibrationElementIDsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.calibration_element_ids, response.status
+
+    def calkit_manager_calkit_set_description(self, selector_string, calkit_description):
+        """calkit_manager_calkit_set_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitSetDescription,
+            grpc_types.CalkitManagerCalkitSetDescriptionRequest(instrument=self._vi, selector_string=selector_string, calkit_description=calkit_description),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_set_version(self, selector_string, calkit_version):
+        """calkit_manager_calkit_set_version."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitSetVersion,
+            grpc_types.CalkitManagerCalkitSetVersionRequest(instrument=self._vi, selector_string=selector_string, calkit_version=calkit_version),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_set_trl_reference_plane(self, selector_string, reference_plane):
+        """calkit_manager_calkit_set_trl_reference_plane."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitSetTRLReferencePlane,
+            grpc_types.CalkitManagerCalkitSetTRLReferencePlaneRequest(instrument=self._vi, selector_string=selector_string, reference_plane_raw=reference_plane),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_set_lrl_line_auto_char(
+        self, selector_string, auto_characterization_enabled
+    ):
+        """calkit_manager_calkit_set_lrl_line_auto_char."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitSetLRLLineAutoChar,
+            grpc_types.CalkitManagerCalkitSetLRLLineAutoCharRequest(instrument=self._vi, selector_string=selector_string, auto_characterization_enabled=auto_characterization_enabled),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_description(self, selector_string, description):
+        """calkit_manager_calkit_connector_set_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetDescription,
+            grpc_types.CalkitManagerCalkitConnectorSetDescriptionRequest(instrument=self._vi, selector_string=selector_string, description=description),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_gender(self, selector_string, connector_gender):
+        """calkit_manager_calkit_connector_set_gender."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetGender,
+            grpc_types.CalkitManagerCalkitConnectorSetGenderRequest(instrument=self._vi, selector_string=selector_string, connector_gender_raw=connector_gender),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_type(self, selector_string, connector_type):
+        """calkit_manager_calkit_connector_set_type."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetType,
+            grpc_types.CalkitManagerCalkitConnectorSetTypeRequest(instrument=self._vi, selector_string=selector_string, connector_type=connector_type),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_impedance(self, selector_string, impedance):
+        """calkit_manager_calkit_connector_set_impedance."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetImpedance,
+            grpc_types.CalkitManagerCalkitConnectorSetImpedanceRequest(instrument=self._vi, selector_string=selector_string, impedance=impedance),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_minimum_frequency(
+        self, selector_string, minimum_frequency
+    ):
+        """calkit_manager_calkit_connector_set_minimum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetMinimumFrequency,
+            grpc_types.CalkitManagerCalkitConnectorSetMinimumFrequencyRequest(instrument=self._vi, selector_string=selector_string, minimum_frequency=minimum_frequency),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_connector_set_maximum_frequency(
+        self, selector_string, maximum_frequency
+    ):
+        """calkit_manager_calkit_connector_set_maximum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorSetMaximumFrequency,
+            grpc_types.CalkitManagerCalkitConnectorSetMaximumFrequencyRequest(instrument=self._vi, selector_string=selector_string, maximum_frequency=maximum_frequency),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_set_description(
+        self, selector_string, description
+    ):
+        """calkit_manager_calkit_calibration_element_set_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetDescription,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetDescriptionRequest(instrument=self._vi, selector_string=selector_string, description=description),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_set_types(
+        self, selector_string, calibration_element_types
+    ):
+        """calkit_manager_calkit_calibration_element_set_types."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetTypes,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetTypesRequest(instrument=self._vi, selector_string=selector_string, calibration_element_types=calibration_element_types),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_get_port_connectors(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_port_connectors."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetPortConnectors,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetPortConnectorsRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.connector_ids, response.status
+
+    def calkit_manager_calkit_calibration_element_set_s_parameter_definition(
+        self, selector_string, s_parameter_definition
+    ):
+        """calkit_manager_calkit_calibration_element_set_s_parameter_definition."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetSParameterDefinition,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetSParameterDefinitionRequest(instrument=self._vi, selector_string=selector_string, s_parameter_definition_raw=s_parameter_definition),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_set_minimum_frequency(
+        self, selector_string, minimum_frequency
+    ):
+        """calkit_manager_calkit_calibration_element_set_minimum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetMinimumFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetMinimumFrequencyRequest(instrument=self._vi, selector_string=selector_string, minimum_frequency=minimum_frequency),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_set_maximum_frequency(
+        self, selector_string, maximum_frequency
+    ):
+        """calkit_manager_calkit_calibration_element_set_maximum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetMaximumFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetMaximumFrequencyRequest(instrument=self._vi, selector_string=selector_string, maximum_frequency=maximum_frequency),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_model_type(
+        self, selector_string, model_type
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_model_type."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetModelType,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetModelTypeRequest(instrument=self._vi, selector_string=selector_string, model_type_raw=model_type),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_s_param_availability(
+        self, selector_string, s_parameter_availability
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_s_param_availability."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetSParamAvailability,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetSParamAvailabilityRequest(instrument=self._vi, selector_string=selector_string, s_parameter_availability_raw=s_parameter_availability),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c0(self, selector_string, c0):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c0."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetC0,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetC0Request(instrument=self._vi, selector_string=selector_string, c0=c0),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c1(self, selector_string, c1):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c1."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetC1,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetC1Request(instrument=self._vi, selector_string=selector_string, c1=c1),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c2(self, selector_string, c2):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c2."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetC2,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetC2Request(instrument=self._vi, selector_string=selector_string, c2=c2),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_c3(self, selector_string, c3):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_c3."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetC3,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetC3Request(instrument=self._vi, selector_string=selector_string, c3=c3),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_delay(
+        self, selector_string, offset_delay
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_delay."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetDelay,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetDelayRequest(instrument=self._vi, selector_string=selector_string, offset_delay=offset_delay),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_loss(
+        self, selector_string, offset_loss
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_loss."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetLoss,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetLossRequest(instrument=self._vi, selector_string=selector_string, offset_loss=offset_loss),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_offset_z0(
+        self, selector_string, offset_z0
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_offset_z0."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetZ0,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetOffsetZ0Request(instrument=self._vi, selector_string=selector_string, offset_z0=offset_z0),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_set_reference_impedance(
+        self, selector_string, reference_impedance
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_set_reference_impedance."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelSetReferenceImpedance,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelSetReferenceImpedanceRequest(instrument=self._vi, selector_string=selector_string, reference_impedance=reference_impedance),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_delay_model_set_delay(
+        self, selector_string, delay
+    ):
+        """calkit_manager_calkit_calibration_element_delay_model_set_delay."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementDelayModelSetDelay,
+            grpc_types.CalkitManagerCalkitCalibrationElementDelayModelSetDelayRequest(instrument=self._vi, selector_string=selector_string, delay=delay),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_frequency(
+        self, selector_string, frequency
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetFrequencyRequest(instrument=self._vi, selector_string=selector_string, frequency=frequency),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s_param_availability(
+        self, selector_string, s_parameter_availability
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s_param_availability."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetSParamAvailability,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetSParamAvailabilityRequest(instrument=self._vi, selector_string=selector_string, s_parameter_availability_raw=s_parameter_availability),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s11(self, selector_string, s11):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s11."""
+        _helper.validate_numpy_array(s11, "s11", "complex128")
+        s11_proto = s11.view(numpy.float64)
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetS11InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetS11InterleavedIQRequest(instrument=self._vi, selector_string=selector_string, s11=s11_proto),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s12(self, selector_string, s12):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s12."""
+        _helper.validate_numpy_array(s12, "s12", "complex128")
+        s12_proto = s12.view(numpy.float64)
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetS12InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetS12InterleavedIQRequest(instrument=self._vi, selector_string=selector_string, s12=s12_proto),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s21(self, selector_string, s21):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s21."""
+        _helper.validate_numpy_array(s21, "s21", "complex128")
+        s21_proto = s21.view(numpy.float64)
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetS21InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetS21InterleavedIQRequest(instrument=self._vi, selector_string=selector_string, s21=s21_proto),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_s22(self, selector_string, s22):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_s22."""
+        _helper.validate_numpy_array(s22, "s22", "complex128")
+        s22_proto = s22.view(numpy.float64)
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetS22InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetS22InterleavedIQRequest(instrument=self._vi, selector_string=selector_string, s22=s22_proto),  # type: ignore
+        )
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_set_from_file(
+        self, selector_string, file_name
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_set_from_file."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterSetFromFile,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterSetFromFileRequest(instrument=self._vi, selector_string=selector_string, file_name=file_name),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_number_of_markers(self, selector_string, number_of_markers):
+        """marker_configure_number_of_markers."""
+        response = self._invoke(
+            self._client.MarkerCfgNumberOfMarkers,
+            grpc_types.MarkerCfgNumberOfMarkersRequest(instrument=self._vi, selector_string=selector_string, number_of_markers=number_of_markers),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_type(self, selector_string, marker_type):
+        """marker_configure_type."""
+        response = self._invoke(
+            self._client.MarkerCfgType,
+            grpc_types.MarkerCfgTypeRequest(instrument=self._vi, selector_string=selector_string, marker_type_raw=marker_type),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_reference_marker(self, selector_string, reference_marker):
+        """marker_configure_reference_marker."""
+        response = self._invoke(
+            self._client.MarkerCfgReferenceMarker,
+            grpc_types.MarkerCfgReferenceMarkerRequest(instrument=self._vi, selector_string=selector_string, reference_marker=reference_marker),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_x(self, selector_string, marker_x):
+        """marker_configure_x."""
+        response = self._invoke(
+            self._client.MarkerCfgX,
+            grpc_types.MarkerCfgXRequest(instrument=self._vi, selector_string=selector_string, marker_x=marker_x),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_y(self, selector_string, marker_y1, marker_y2):
+        """marker_configure_y."""
+        response = self._invoke(
+            self._client.MarkerCfgY,
+            grpc_types.MarkerCfgYRequest(instrument=self._vi, selector_string=selector_string, marker_y1=marker_y1, marker_y2=marker_y2),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_data_source(self, selector_string, data_source):
+        """marker_configure_data_source."""
+        response = self._invoke(
+            self._client.MarkerCfgDataSource,
+            grpc_types.MarkerCfgDataSourceRequest(instrument=self._vi, selector_string=selector_string, data_source=data_source),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_peak_search_threshold(self, selector_string, threshold_enabled, threshold):
+        """marker_configure_peak_search_threshold."""
+        response = self._invoke(
+            self._client.MarkerCfgPeakSearchThreshold,
+            grpc_types.MarkerCfgPeakSearchThresholdRequest(instrument=self._vi, selector_string=selector_string, threshold_enabled_raw=threshold_enabled, threshold=threshold),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_peak_search_excursion(
+        self, selector_string, peak_excursion_enabled, peak_excursion
+    ):
+        """marker_configure_peak_search_excursion."""
+        response = self._invoke(
+            self._client.MarkerCfgPeakSearchExcursion,
+            grpc_types.MarkerCfgPeakSearchExcursionRequest(instrument=self._vi, selector_string=selector_string, peak_excursion_enabled_raw=peak_excursion_enabled, peak_excursion=peak_excursion),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_mode(self, selector_string, marker_mode):
+        """marker_configure_mode."""
+        response = self._invoke(
+            self._client.MarkerCfgMode,
+            grpc_types.MarkerCfgModeRequest(instrument=self._vi, selector_string=selector_string, marker_mode_raw=marker_mode),  # type: ignore
+        )
+        return response.status
+
+    def marker_configure_target_value(self, selector_string, target_value):
+        """marker_configure_target_value."""
+        response = self._invoke(
+            self._client.MarkerCfgTargetValue,
+            grpc_types.MarkerCfgTargetValueRequest(instrument=self._vi, selector_string=selector_string, target_value=target_value),  # type: ignore
+        )
+        return response.status
+
+    def marker_marker_search(self, selector_string, search_mode):
+        """marker_marker_search."""
+        response = self._invoke(
+            self._client.MarkerSearch,
+            grpc_types.MarkerSearchRequest(instrument=self._vi, selector_string=selector_string, search_mode_raw=search_mode),  # type: ignore
+        )
+        return response.status
+
+    def marker_fetch_x(self, selector_string):
+        """marker_fetch_x."""
+        response = self._invoke(
+            self._client.MarkerFetchX,
+            grpc_types.MarkerFetchXRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.marker_x, response.status
+
+    def marker_fetch_y(self, selector_string):
+        """marker_fetch_y."""
+        response = self._invoke(
+            self._client.MarkerFetchY,
+            grpc_types.MarkerFetchYRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.marker_y1, response.marker_y2, response.status
+
+    def calkit_manager_calkit_get_trl_reference_plane(self, selector_string):
+        """calkit_manager_calkit_get_trl_reference_plane."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetTRLReferencePlane,
+            grpc_types.CalkitManagerCalkitGetTRLReferencePlaneRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return enums.CalkitManagerCalkitTrlReferencePlane(response.reference_plane), response.status
+
+    def calkit_manager_calkit_get_lrl_line_auto_char(self, selector_string):
+        """calkit_manager_calkit_get_lrl_line_auto_char."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetLRLLineAutoChar,
+            grpc_types.CalkitManagerCalkitGetLRLLineAutoCharRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return bool(response.auto_characterization_enabled), response.status
+
+    def calkit_manager_calkit_connector_get_gender(self, selector_string):
+        """calkit_manager_calkit_connector_get_gender."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetGender,
+            grpc_types.CalkitManagerCalkitConnectorGetGenderRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return enums.CalkitManagerCalkitConnectorGender(response.connector_gender), response.status
+
+    def calkit_manager_calkit_connector_get_impedance(self, selector_string):
+        """calkit_manager_calkit_connector_get_impedance."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetImpedance,
+            grpc_types.CalkitManagerCalkitConnectorGetImpedanceRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.impedance, response.status
+
+    def calkit_manager_calkit_connector_get_minimum_frequency(self, selector_string):
+        """calkit_manager_calkit_connector_get_minimum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetMinimumFrequency,
+            grpc_types.CalkitManagerCalkitConnectorGetMinimumFrequencyRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.minimum_frequency, response.status
+
+    def calkit_manager_calkit_connector_get_maximum_frequency(self, selector_string):
+        """calkit_manager_calkit_connector_get_maximum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetMaximumFrequency,
+            grpc_types.CalkitManagerCalkitConnectorGetMaximumFrequencyRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.maximum_frequency, response.status
+
+    def calkit_manager_calkit_calibration_element_get_s_parameter_definition(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_s_parameter_definition."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetSParameterDefinition,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetSParameterDefinitionRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return (
+            enums.CalkitManagerCalkitCalibrationElementSParameterDefinition(
+                response.s_parameter_definition
+            ),
+            response.status,
+        )
+
+    def calkit_manager_calkit_calibration_element_get_minimum_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_minimum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetMinimumFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetMinimumFrequencyRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.minimum_frequency, response.status
+
+    def calkit_manager_calkit_calibration_element_get_maximum_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_maximum_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetMaximumFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetMaximumFrequencyRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.maximum_frequency, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_model_type(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_model_type."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetModelType,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetModelTypeRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return (
+            enums.CalkitManagerCalkitCalibrationElementReflectModelType(response.model_type),
+            response.status,
+        )
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_s_param_availability(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_s_param_availability."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetSParamAvailability,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetSParamAvailabilityRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return (
+            enums.CalkitManagerCalkitCalibrationElementReflectModelSParameterAvailability(
+                response.s_parameter_availability
+            ),
+            response.status,
+        )
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c0(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c0."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetC0,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetC0Request(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.c0, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c1(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c1."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetC1,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetC1Request(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.c1, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c2(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c2."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetC2,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetC2Request(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.c2, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_c3(self, selector_string):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_c3."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetC3,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetC3Request(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.c3, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_delay(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_delay."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetDelay,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetDelayRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.offset_delay, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_loss(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_loss."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetLoss,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetLossRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.offset_loss, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_offset_z0(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_offset_z0."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetZ0,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetOffsetZ0Request(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.offset_z0, response.status
+
+    def calkit_manager_calkit_calibration_element_reflect_model_get_reference_impedance(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_reflect_model_get_reference_impedance."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementReflectModelGetReferenceImpedance,
+            grpc_types.CalkitManagerCalkitCalibrationElementReflectModelGetReferenceImpedanceRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.reference_impedance, response.status
+
+    def calkit_manager_calkit_calibration_element_delay_model_get_delay(self, selector_string):
+        """calkit_manager_calkit_calibration_element_delay_model_get_delay."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementDelayModelGetDelay,
+            grpc_types.CalkitManagerCalkitCalibrationElementDelayModelGetDelayRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.delay, response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s_param_availability(
+        self, selector_string
+    ):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s_param_availability."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetSParamAvailability,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetSParamAvailabilityRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return (
+            enums.CalkitManagerCalkitCalibrationElementSParameterAvailability(
+                response.s_parameter_availability
+            ),
+            response.status,
+        )
+
+    def s_params_fetch_x_data(self, selector_string, timeout):
+        """s_params_fetch_x_data."""
+        response = self._invoke(
+            self._client.SParamsFetchXData,
+            grpc_types.SParamsFetchXDataRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.x[:], response.status
+
+    def s_params_fetch_y_data(self, selector_string, timeout):
+        """s_params_fetch_y_data."""
+        response = self._invoke(
+            self._client.SParamsFetchYData,
+            grpc_types.SParamsFetchYDataRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.y1[:], response.y2[:], response.status
+
+    def waves_fetch_x_data(self, selector_string, timeout):
+        """waves_fetch_x_data."""
+        response = self._invoke(
+            self._client.WavesFetchXData,
+            grpc_types.WavesFetchXDataRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.x[:], response.status
+
+    def waves_fetch_y_data(self, selector_string, timeout):
+        """waves_fetch_y_data."""
+        response = self._invoke(
+            self._client.WavesFetchYData,
+            grpc_types.WavesFetchYDataRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        return response.y1[:], response.y2[:], response.status
+
+    def iq_fetch_data(self, selector_string, timeout, data):
+        """iq_fetch_data."""
+        response = self._invoke(
+            self._client.IQFetchDataInterleavedIQ,
+            grpc_types.IQFetchDataInterleavedIQRequest(instrument=self._vi, selector_string=selector_string, timeout=timeout),  # type: ignore
+        )
+        _helper.validate_numpy_array(data, "data", "complex64")
+        if len(data) != response.actual_array_size // 2:
+            data.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.data, dtype=numpy.float32)
+        data[:] = flat.view(numpy.complex64)
+        return response.x0, response.dx, response.status
+
+    def calset_get_frequency_grid(self, selector_string, calset_name, error_term_identifier):
+        """calset_get_frequency_grid."""
+        response = self._invoke(
+            self._client.CalsetGetFrequencyGrid,
+            grpc_types.CalsetGetFrequencyGridRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, error_term_identifier_raw=error_term_identifier),  # type: ignore
+        )
+        return response.frequency_grid[:], response.status
+
+    def calset_get_error_term(
+        self,
+        selector_string,
+        calset_name,
+        error_term_identifier,
+        measurement_port,
+        source_port,
+        error_term,
+    ):
+        """calset_get_error_term."""
+        response = self._invoke(
+            self._client.CalsetGetErrorTermInterleavedIQ,
+            grpc_types.CalsetGetErrorTermInterleavedIQRequest(instrument=self._vi, selector_string=selector_string, calset_name=calset_name, error_term_identifier_raw=error_term_identifier, measurement_port=measurement_port, source_port=source_port),  # type: ignore
+        )
+        _helper.validate_numpy_array(error_term, "error_term", "complex64")
+        if len(error_term) != response.actual_array_size // 2:
+            error_term.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.error_term, dtype=numpy.float32)
+        error_term[:] = flat.view(numpy.complex64)
+        return response.status
+
+    def get_measurement_memory_x_data(self, selector_string):
+        """get_measurement_memory_x_data."""
+        response = self._invoke(
+            self._client.GetMeasurementMemoryXData,
+            grpc_types.GetMeasurementMemoryXDataRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.measurement_memory_x[:], response.status
+
+    def get_measurement_memory_y_data(self, selector_string):
+        """get_measurement_memory_y_data."""
+        response = self._invoke(
+            self._client.GetMeasurementMemoryYData,
+            grpc_types.GetMeasurementMemoryYDataRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.measurement_memory_y1[:], response.measurement_memory_y2[:], response.status
+
+    def calkit_manager_calkit_calibration_element_get_types(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_types."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetTypes,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetTypesRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return [
+            enums.CalkitManagerCalkitCalibrationElementType(value)
+            for value in response.calibration_element_types
+        ], response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_frequency(self, selector_string):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_frequency."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetFrequency,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetFrequencyRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.frequency[:], response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s11(self, selector_string, s11):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s11."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetS11InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetS11InterleavedIQRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        _helper.validate_numpy_array(s11, "s11", "complex128")
+        if len(s11) != response.actual_array_size // 2:
+            s11.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.s11, dtype=numpy.float64)
+        s11[:] = flat.view(numpy.complex128)
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s12(self, selector_string, s12):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s12."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetS12InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetS12InterleavedIQRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        _helper.validate_numpy_array(s12, "s12", "complex128")
+        if len(s12) != response.actual_array_size // 2:
+            s12.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.s12, dtype=numpy.float64)
+        s12[:] = flat.view(numpy.complex128)
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s21(self, selector_string, s21):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s21."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetS21InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetS21InterleavedIQRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        _helper.validate_numpy_array(s21, "s21", "complex128")
+        if len(s21) != response.actual_array_size // 2:
+            s21.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.s21, dtype=numpy.float64)
+        s21[:] = flat.view(numpy.complex128)
+        return response.status
+
+    def calkit_manager_calkit_calibration_element_s_parameter_get_s22(self, selector_string, s22):
+        """calkit_manager_calkit_calibration_element_s_parameter_get_s22."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSParameterGetS22InterleavedIQ,
+            grpc_types.CalkitManagerCalkitCalibrationElementSParameterGetS22InterleavedIQRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        _helper.validate_numpy_array(s22, "s22", "complex128")
+        if len(s22) != response.actual_array_size // 2:
+            s22.resize((response.actual_array_size // 2,), refcheck=False)
+        flat = numpy.array(response.s22, dtype=numpy.float64)
+        s22[:] = flat.view(numpy.complex128)
+        return response.status
+
+    def clone_signal_configuration(self, old_signal_name, new_signal_name):
+        """clone_signal_configuration."""
+        response = self._invoke(
+            self._client.CloneSignalConfiguration,
+            grpc_types.CloneSignalConfigurationRequest(instrument=self._vi, old_signal_name=old_signal_name, new_signal_name=new_signal_name),  # type: ignore
+        )
+        import nirfmxvna
+
+        signal_configuration = nirfmxvna._VnaSignalConfiguration.get_vna_signal_configuration(self._instr_session, new_signal_name, True)  # type: ignore
+        return signal_configuration, response.status
+
+    def delete_signal_configuration(self, ignore_driver_error):
+        """delete_signal_configuration."""
+        response = self._invoke(
+            self._client.DeleteSignalConfiguration,
+            grpc_types.DeleteSignalConfigurationRequest(instrument=self._vi, signal_name=self._signal_obj.signal_configuration_name),  # type: ignore
+            None,
+            ignore_driver_error,
+        )
+        if ignore_driver_error:
+            return 0
+        else:
+            return response.status
+
+    def send_software_edge_trigger(self):
+        """send_software_edge_trigger."""
+        response = self._invoke(
+            self._client.SendSoftwareEdgeTrigger,
+            grpc_types.SendSoftwareEdgeTriggerRequest(instrument=self._vi),  # type: ignore
+        )
+        return response.status
+
+    def get_all_named_result_names(self, selector_string):
+        """get_all_named_result_names."""
+        response = self._invoke(
+            self._client.GetAllNamedResultNames,
+            grpc_types.GetAllNamedResultNamesRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return (
+            _helper.split_string_by_comma(response.result_names),
+            bool(response.default_result_exists),
+            response.status,
+        )
+
+    def calkit_manager_calkit_get_description(self, selector_string):
+        """calkit_manager_calkit_get_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetDescription,
+            grpc_types.CalkitManagerCalkitGetDescriptionRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.calkit_description, response.status
+
+    def calkit_manager_calkit_get_version(self, selector_string):
+        """calkit_manager_calkit_get_version."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitGetVersion,
+            grpc_types.CalkitManagerCalkitGetVersionRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.calkit_version, response.status
+
+    def calkit_manager_calkit_connector_get_description(self, selector_string):
+        """calkit_manager_calkit_connector_get_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetDescription,
+            grpc_types.CalkitManagerCalkitConnectorGetDescriptionRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.description, response.status
+
+    def calkit_manager_calkit_connector_get_type(self, selector_string):
+        """calkit_manager_calkit_connector_get_type."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitConnectorGetType,
+            grpc_types.CalkitManagerCalkitConnectorGetTypeRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.connector_type, response.status
+
+    def calkit_manager_calkit_calibration_element_get_description(self, selector_string):
+        """calkit_manager_calkit_calibration_element_get_description."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementGetDescription,
+            grpc_types.CalkitManagerCalkitCalibrationElementGetDescriptionRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.description, response.status
+
+    def calkit_manager_calkit_calibration_element_set_port_connectors(
+        self, selector_string, connector_ids
+    ):
+        """calkit_manager_calkit_calibration_element_set_port_connectors."""
+        response = self._invoke(
+            self._client.CalkitManagerCalkitCalibrationElementSetPortConnectors,
+            grpc_types.CalkitManagerCalkitCalibrationElementSetPortConnectorsRequest(instrument=self._vi, selector_string=selector_string, connector_ids=connector_ids, array_size=len(connector_ids) if connector_ids is not None else 0),  # type: ignore
+        )
+        return response.status
+
+    def get_s_parameter(self, selector_string):
+        """get_s_parameter."""
+        response = self._invoke(
+            self._client.SParamsGetSParameter,
+            grpc_types.SParamsGetSParameterRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.s_parameter, response.status
+
+    def get_wave(self, selector_string):
+        """get_wave."""
+        response = self._invoke(
+            self._client.WavesGetWave,
+            grpc_types.WavesGetWaveRequest(instrument=self._vi, selector_string=selector_string),  # type: ignore
+        )
+        return response.wave, response.status