nirfmxlte 26.0.0__py3-none-any.whl

nirfmxlte/__init__.py

@@ -0,0 +1,106 @@
+"""nirfmxlte package."""
+
+__version__ = "26.0.0"
+
+from nirfmxlte.attributes import *  # noqa: F403
+from nirfmxlte.enums import *  # noqa: F403
+from nirfmxlte.grpc_session_options import *  # noqa: F403
+from nirfmxlte.lte import Lte, _LteSignalConfiguration
+
+
+def get_diagnostic_information():
+    """Get diagnostic information about the system state that is suitable for printing or logging.
+    returns: dict
+    note: Python bitness may be incorrect when running in a virtual environment.
+    """
+    import importlib.metadata
+    import os
+    import platform
+    import struct
+    import sys
+
+    def is_python_64bit():
+        return struct.calcsize("P") == 8
+
+    def is_os_64bit():
+        return platform.machine().endswith("64")
+
+    def is_venv():
+        return "VIRTUAL_ENV" in os.environ
+
+    info = {}  # type: ignore
+    info["os"] = {}
+    info["python"] = {}
+    info["driver"] = {}
+    info["module"] = {}
+    if platform.system() == "Windows":
+        try:
+            import winreg as winreg
+        except ImportError:
+            import _winreg as winreg  # type: ignore
+
+        os_name = "Windows"
+        try:
+            driver_version_key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\National Instruments\RFmx\LTE\C Runtime Support")  # type: ignore
+            driver_version = winreg.QueryValueEx(driver_version_key, "Version")[0]  # type: ignore
+        except WindowsError:  # type: ignore
+            driver_version = "Unknown"
+    else:
+        raise SystemError("Unsupported platform: {}".format(platform.system()))
+
+    if sys.version_info[1] >= 10:
+        installed_packages_names = [
+            name
+            for name_list in importlib.metadata.packages_distributions().values()
+            for name in name_list
+        ]
+        installed_packages_names = set(installed_packages_names)  # type: ignore
+        installed_packages_list = [
+            {"name": name, "version": importlib.metadata.distribution(name).version}
+            for name in sorted(installed_packages_names)
+        ]
+    else:
+        import pkg_resources
+
+        installed_packages = pkg_resources.working_set
+        installed_packages_list = [
+            {
+                "name": i.key,
+                "version": i.version,
+            }
+            for i in installed_packages
+        ]
+
+    info["os"]["name"] = os_name
+    info["os"]["version"] = platform.version()
+    info["os"]["bits"] = "64" if is_os_64bit() else "32"  # type: ignore
+    info["driver"]["name"] = "RFmx LTE"
+    info["driver"]["version"] = driver_version
+    info["module"]["name"] = "nirfmxlte"
+    info["module"]["version"] = "26.0.0"
+    info["python"]["version"] = sys.version
+    info["python"]["bits"] = "64" if is_python_64bit() else "32"  # type: ignore
+    info["python"]["is_venv"] = is_venv()  # type: ignore
+    info["python"]["packages"] = installed_packages_list
+
+    return info
+
+
+def print_diagnostic_information():
+    """Print diagnostic information in a format suitable for issue report.
+    note: Python bitness may be incorrect when running in a virtual environment.
+    """
+    info = get_diagnostic_information()  # type: ignore
+
+    row_format = "    {:<10"
+    for type in ["OS", "Driver", "Module", "Python"]:
+        typename = type.lower()
+        print(type + ":")
+        for item in info[typename]:
+            if item != "packages":
+                print(row_format.format(item.title() + ":", info[typename][item]))
+    print("    Installed Packages:")
+    for p in info["python"]["packages"]:
+        print((" " * 8) + p["name"] + "==" + p["version"])
+
+    return info

nirfmxlte/acp.py

@@ -0,0 +1,31 @@
+"""Represents the Acp measurement."""
+
+import functools
+
+import nirfmxlte.acp_configuration as configuration
+import nirfmxlte.acp_results as results
+
+
+def _raise_if_disposed(f):
+    """From https://stackoverflow.com/questions/5929107/decorators-with-parameters."""
+
+    @functools.wraps(f)
+    def aux(*xs, **kws):
+        meas_obj = xs[0]  # parameter 0 is 'self' which is the measurement object
+        if meas_obj._signal_obj.is_disposed:
+            raise Exception("Cannot access a disposed Lte signal configuration")
+        return f(*xs, **kws)
+
+    return aux
+
+
+class Acp(object):
+    """Represents the Acp measurement."""
+
+    def __init__(self, signal_obj):
+        """Represents the Acp measurement."""
+        self._signal_obj = signal_obj
+        self._session_function_lock = signal_obj._session_function_lock
+        self._interpreter = signal_obj._interpreter
+        self.configuration = configuration.AcpConfiguration(signal_obj)  # type: ignore
+        self.results = results.AcpResults(signal_obj)  # type: ignore

nirfmxlte/acp_component_carrier_results.py

@@ -0,0 +1,208 @@
+""""""
+
+import functools
+
+import nirfmxlte.attributes as attributes
+import nirfmxlte.errors as errors
+import nirfmxlte.internal._helper as _helper
+
+
+def _raise_if_disposed(f):
+    """From https://stackoverflow.com/questions/5929107/decorators-with-parameters."""
+
+    @functools.wraps(f)
+    def aux(*xs, **kws):
+        meas_obj = xs[0]  # parameter 0 is 'self' which is the measurement object
+        if meas_obj._signal_obj.is_disposed:
+            raise Exception("Cannot access a disposed Lte signal configuration")
+        return f(*xs, **kws)
+
+    return aux
+
+
+class AcpComponentCarrierResults(object):
+    """"""
+
+    def __init__(self, signal_obj):
+        """"""
+        self._signal_obj = signal_obj
+        self._session_function_lock = signal_obj._session_function_lock
+        self._interpreter = signal_obj._interpreter
+
+    @_raise_if_disposed
+    def get_absolute_power(self, selector_string):
+        r"""Gets the power measured over the integration bandwidth of the carrier. The carrier power is reported in dBm when you
+        set the :py:attr:`~nirfmxlte.attributes.AttributeID.ACP_POWER_UNITS` attribute to **dBm**, and in dBm/Hz when you set
+        the ACP Pwr Units attribute to **dBm/Hz**.
+
+        Use "carrier<*k*>" or "subblock<*n*>/carrier<*k*>" as the selector string to read this result.
+
+        Args:
+            selector_string (string):
+                Pass an empty string.
+
+        Returns:
+            Tuple (attr_val, error_code):
+
+            attr_val (float):
+                Returns the power measured over the integration bandwidth of the carrier. The carrier power is reported in dBm when you
+                set the :py:attr:`~nirfmxlte.attributes.AttributeID.ACP_POWER_UNITS` attribute to **dBm**, and in dBm/Hz when you set
+                the ACP Pwr Units attribute to **dBm/Hz**.
+
+            error_code (int):
+                Returns the status code of this method. The status code either indicates success or describes a warning condition.
+        """
+        try:
+            self._session_function_lock.enter_read_lock()
+            updated_selector_string = _helper.validate_and_update_selector_string(
+                selector_string, self._signal_obj
+            )
+            attr_val, error_code = self._interpreter.get_attribute_f64(
+                updated_selector_string,
+                attributes.AttributeID.ACP_RESULTS_COMPONENT_CARRIER_ABSOLUTE_POWER.value,
+            )
+        finally:
+            self._session_function_lock.exit_read_lock()
+
+        return attr_val, error_code
+
+    @_raise_if_disposed
+    def get_relative_power(self, selector_string):
+        r"""Gets the component carrier power relative to its subblock power. This value is expressed in dB.
+
+        Use "carrier<*k*>" or "subblock<*n*>/carrier<*k*>" as the selector string to read this result.
+
+        Args:
+            selector_string (string):
+                Pass an empty string.
+
+        Returns:
+            Tuple (attr_val, error_code):
+
+            attr_val (float):
+                Returns the component carrier power relative to its subblock power. This value is expressed in dB.
+
+            error_code (int):
+                Returns the status code of this method. The status code either indicates success or describes a warning condition.
+        """
+        try:
+            self._session_function_lock.enter_read_lock()
+            updated_selector_string = _helper.validate_and_update_selector_string(
+                selector_string, self._signal_obj
+            )
+            attr_val, error_code = self._interpreter.get_attribute_f64(
+                updated_selector_string,
+                attributes.AttributeID.ACP_RESULTS_COMPONENT_CARRIER_RELATIVE_POWER.value,
+            )
+        finally:
+            self._session_function_lock.exit_read_lock()
+
+        return attr_val, error_code
+
+    @_raise_if_disposed
+    def fetch_measurement_array(self, selector_string, timeout):
+        r"""Returns an array of the absolute and relative powers of the component carriers. The relative power is relative to the
+        subblock power.
+
+        Use "subblock<*n*>" as the selector string to read results from this method.
+
+        Args:
+            selector_string (string):
+                This parameter specifies a `Selector String
+                <https://www.ni.com/docs/en-US/bundle/rfmx/page/selector-strings-net.html>`_ comprising of result
+                name, and subblock number.
+
+                Example:
+
+                "subblock0"
+
+                "result::r1/subblock0"
+
+                You can use the :py:meth:`build_subblock_string` method to build the selector string.
+
+            timeout (float):
+                This parameter specifies the timeout for fetching the specified measurement. This value is expressed in seconds. Set
+                this value to an appropriate time, longer than expected for fetching the measurement. A value of -1 specifies that the
+                method waits until the measurement is complete. The default value is 10.
+
+        Returns:
+            Tuple (absolute_power, relative_power, error_code):
+
+            absolute_power (float):
+                This parameter returns the array of powers measured over the integration bandwidths of the carriers. The carrier power
+                is reported in dBm when you set the :py:attr:`~nirfmxlte.attributes.AttributeID.ACP_POWER_UNITS` attribute to **dBm**,
+                and in dBm/Hz when you set the ACP Pwr Units attribute to **dBm/Hz**.
+
+            relative_power (float):
+                This parameter returns the array of component carrier powers relative to their subblock powers measured over the
+                integration bandwidths of the component carriers in the subblock. This value is expressed in dB.
+
+            error_code (int):
+                Returns the status code of this method. The status code either indicates success or describes a warning condition.
+        """
+        try:
+            self._session_function_lock.enter_read_lock()
+            _helper.validate_not_none(selector_string, "selector_string")
+            updated_selector_string = _helper.validate_and_update_selector_string(
+                selector_string, self._signal_obj
+            )
+            absolute_power, relative_power, error_code = (
+                self._interpreter.acp_fetch_measurement_array(updated_selector_string, timeout)
+            )
+        finally:
+            self._session_function_lock.exit_read_lock()
+
+        return absolute_power, relative_power, error_code
+
+    @_raise_if_disposed
+    def fetch_measurement(self, selector_string, timeout):
+        r"""Fetches the ACP component carrier measurement.
+
+        Use "carrier<*k*>" or "subblock<*n*>/carrier<*k*>" as the selector string to read results from this method.
+
+        Args:
+            selector_string (string):
+                This parameter specifies a `Selector String
+                <https://www.ni.com/docs/en-US/bundle/rfmx/page/selector-strings-net.html>`_ comprising of result
+                name, subblock number, and carrier number.
+
+                Example:
+
+                "subblock0/carrier0"
+
+                "result::r1/subblock0/carrier0"
+
+                You can use the :py:meth:`build_carrier_string` method to build the selector string.
+
+            timeout (float):
+                This parameter specifies the timeout for fetching the specified measurement. This value is expressed in seconds. Set
+                this value to an appropriate time, longer than expected for fetching the measurement. A value of -1 specifies that the
+                method waits until the measurement is complete. The default value is 10.
+
+        Returns:
+            Tuple (absolute_power, relative_power, error_code):
+
+            absolute_power (float):
+                This parameter returns the power measured over the integration bandwidth of the carrier. The carrier power is reported
+                in dBm when you set the :py:attr:`~nirfmxlte.attributes.AttributeID.ACP_POWER_UNITS` attribute to **dBm**, and in
+                dBm/Hz when you set the ACP Pwr Units attribute to **dBm/Hz**.
+
+            relative_power (float):
+                This parameter returns the component carrier power relative to its subblock power. This value is expressed in dB.
+
+            error_code (int):
+                Returns the status code of this method. The status code either indicates success or describes a warning condition.
+        """
+        try:
+            self._session_function_lock.enter_read_lock()
+            _helper.validate_not_none(selector_string, "selector_string")
+            updated_selector_string = _helper.validate_and_update_selector_string(
+                selector_string, self._signal_obj
+            )
+            absolute_power, relative_power, error_code = self._interpreter.acp_fetch_measurement(
+                updated_selector_string, timeout
+            )
+        finally:
+            self._session_function_lock.exit_read_lock()
+
+        return absolute_power, relative_power, error_code