ni.measurementlink.sessionmanagement.v1.client 0.1.0.dev0__py3-none-any.whl

ni/measurementlink/sessionmanagement/v1/client/_drivers/_configuration.py

@@ -0,0 +1,111 @@
+"""Measurement plug-in configuration options."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, TypeVar
+
+from decouple import AutoConfig, Undefined, undefined
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._dotenvpath import (
+    get_dotenv_search_path,
+)
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 11):
+        from typing import Self
+    else:
+        from typing_extensions import Self
+
+
+_PREFIX = "MEASUREMENT_PLUGIN"
+
+_config = AutoConfig(str(get_dotenv_search_path()))
+
+if TYPE_CHECKING:
+    # Work around decouple's lack of type hints.
+    _T = TypeVar("_T")
+
+    def _config(
+        option: str,
+        default: _T | Undefined = undefined,
+        cast: Callable[[str], _T] | Undefined = undefined,
+    ) -> _T: ...
+
+
+# ----------------------------------------------------------------------
+# NI Modular Instrument Driver Options
+# ----------------------------------------------------------------------
+class MIDriverOptions(NamedTuple):
+    """Modular instrument driver options."""
+
+    driver_name: str
+    """The driver name."""
+
+    simulate: bool = False
+    """Specifies whether to simulate session operations."""
+
+    board_type: str = ""
+    """The simulated board type (bus)."""
+
+    model: str = ""
+    """The simulated instrument model."""
+
+    def update_from_config(self) -> Self:
+        """Read options from the configuration file and return a new options object."""
+        prefix = f"{_PREFIX}_{self.driver_name.upper()}"
+        return self._replace(
+            simulate=_config(f"{prefix}_SIMULATE", default=self.simulate, cast=bool),
+            board_type=_config(f"{prefix}_BOARD_TYPE", default=self.board_type),
+            model=_config(f"{prefix}_MODEL", default=self.model),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert options to a dict to pass to nimi-python."""
+        options: dict[str, Any] = {}
+        if self.simulate:
+            options["simulate"] = True
+        if self.board_type or self.model:
+            options["driver_setup"] = {}
+            if self.board_type:
+                options["driver_setup"]["BoardType"] = self.board_type
+            if self.model:
+                options["driver_setup"]["Model"] = self.model
+        return options
+
+
+class NISwitchOptions(NamedTuple):
+    """NI-SWITCH driver options."""
+
+    driver_name: str
+    """The driver name."""
+
+    simulate: bool = False
+    """Specifies whether to simulate session operations."""
+
+    topology: str = "Configured Topology"
+    """The default topology."""
+
+    def update_from_config(self) -> Self:
+        """Read options from the configuration file and return a new options object."""
+        prefix = f"{_PREFIX}_{self.driver_name.upper()}"
+        return self._replace(
+            simulate=_config(f"{prefix}_SIMULATE", default=self.simulate, cast=bool),
+            topology=_config(f"{prefix}_TOPOLOGY", default=self.topology),
+        )
+
+
+NIDCPOWER_OPTIONS = MIDriverOptions("nidcpower").update_from_config()
+NIDIGITAL_OPTIONS = MIDriverOptions("nidigital").update_from_config()
+NIDMM_OPTIONS = MIDriverOptions("nidmm").update_from_config()
+NIFGEN_OPTIONS = MIDriverOptions("nifgen").update_from_config()
+NISCOPE_OPTIONS = MIDriverOptions("niscope").update_from_config()
+NISWITCH_OPTIONS = NISwitchOptions("niswitch").update_from_config()
+NISWITCH_MULTIPLEXER_OPTIONS = NISwitchOptions("niswitch_multiplexer").update_from_config()
+
+
+# ----------------------------------------------------------------------
+# NI gRPC Device Server Configuration
+# ----------------------------------------------------------------------
+USE_GRPC_DEVICE_SERVER: bool = _config(f"{_PREFIX}_USE_GRPC_DEVICE_SERVER", default=True, cast=bool)
+GRPC_DEVICE_SERVER_ADDRESS: str = _config(f"{_PREFIX}_GRPC_DEVICE_SERVER_ADDRESS", default="")

ni/measurementlink/sessionmanagement/v1/client/_drivers/_dotenvpath.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import inspect
+import sys
+import traceback
+from pathlib import Path
+
+
+def get_dotenv_search_path() -> Path:
+    """Get the search path for loading the `.env` file."""
+    # Prefer to load the `.env` file from the current directory or its parents.
+    # If the current directory doesn't have a `.env` file, fall back to the
+    # script/EXE path or the TestStand code module path.
+    cwd = Path.cwd()
+    if not _has_dotenv_file(cwd):
+        if script_or_exe_path := _get_script_or_exe_path():
+            return script_or_exe_path.resolve().parent
+        if caller_path := _get_caller_path():
+            return caller_path.resolve().parent
+    return cwd
+
+
+def _has_dotenv_file(dir: Path) -> bool:
+    """Check whether the dir or its parents contains a `.env` file."""
+    return (dir / ".env").exists() or any((p / ".env").exists() for p in dir.parents)
+
+
+def _get_script_or_exe_path() -> Path | None:
+    """Get the path of the top-level script or PyInstaller EXE, if possible."""
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable)
+
+    main_module = sys.modules.get("__main__")
+    if main_module:
+        script_path = getattr(main_module, "__file__", "")
+        if script_path:
+            return Path(script_path)
+
+    return None
+
+
+def _get_caller_path() -> Path | None:
+    """Get the path of the module calling into this package, if possible."""
+    package_path = _get_package_path()
+    for frame, _ in traceback.walk_stack(inspect.currentframe()):
+        if frame.f_code.co_filename:
+            module_path = Path(frame.f_code.co_filename)
+            if _exists(module_path) and not module_path.is_relative_to(package_path):
+                return module_path
+
+    return None
+
+
+# Path.exists() throws OSError when the path has invalid file characters.
+# https://github.com/python/cpython/issues/79487
+if sys.version_info >= (3, 10):
+
+    def _exists(path: Path) -> bool:
+        return path.exists()
+
+else:
+
+    def _exists(path: Path) -> bool:
+        import os
+
+        return os.path.exists(path)
+
+
+def _get_package_path() -> Path:
+    """Get the path of this package."""
+    package = sys.modules[__package__]  # pyright: ignore[reportArgumentType]
+    assert package.__file__ and package.__file__.endswith("__init__.py")
+    return Path(package.__file__).parent

ni/measurementlink/sessionmanagement/v1/client/_drivers/_grpcdevice.py

@@ -0,0 +1,96 @@
+"""Shared functions for interacting with NI gRPC Device Server."""
+
+from __future__ import annotations
+
+import logging
+from urllib.parse import urlsplit
+
+import grpc
+from ni.measurementlink.discovery.v1.client import DiscoveryClient, ServiceLocation
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    GRPC_DEVICE_SERVER_ADDRESS,
+    USE_GRPC_DEVICE_SERVER,
+)
+
+_logger = logging.getLogger(__name__)
+
+SERVICE_CLASS = "ni.measurementlink.v1.grpcdeviceserver"
+"""The service class for NI gRPC Device Server."""
+
+
+def get_grpc_device_server_location(
+    discovery_client: DiscoveryClient,
+    provided_interface: str,
+) -> ServiceLocation | None:
+    """Get an address targeting NI gRPC Device Server for unencrypted communication."""
+    if not USE_GRPC_DEVICE_SERVER:
+        _logger.debug("Not using NI gRPC Device Server")
+        return None
+
+    if GRPC_DEVICE_SERVER_ADDRESS:
+        service_location = _parse_url_to_service_location(GRPC_DEVICE_SERVER_ADDRESS)
+        _logger.debug(
+            "NI gRPC Device Server location (from GRPC_DEVICE_SERVER_ADDRESS): %r", service_location
+        )
+        return service_location
+
+    compute_nodes = discovery_client.enumerate_compute_nodes()
+    remote_compute_nodes = [node for node in compute_nodes if not node.is_local]
+    # Use remote node URL as deployment target if only one remote node is found.
+    # If more than one remote node exists, use empty string for deployment target.
+    first_remote_node_url = remote_compute_nodes[0].url if len(remote_compute_nodes) == 1 else ""
+    service_location = discovery_client.resolve_service(
+        provided_interface=provided_interface,
+        deployment_target=first_remote_node_url,
+        service_class=SERVICE_CLASS,
+    )
+    _logger.debug(
+        "NI gRPC Device Server location (for interface '%s'): %r",
+        provided_interface,
+        service_location,
+    )
+    return service_location
+
+
+def _parse_url_to_service_location(url: str) -> ServiceLocation:
+    parsed_url = urlsplit(url)
+
+    if parsed_url.scheme not in ("http", "https"):
+        raise ValueError(f"Unsupported URL scheme '{parsed_url.scheme}' in '{url}'")
+    if parsed_url.path not in ("", "/"):
+        raise ValueError(f"Unsupported path '{parsed_url.path}' in '{url}'")
+    if parsed_url.query:
+        raise ValueError(f"Unsupported query '?{parsed_url.query}' in '{url}'")
+    if parsed_url.fragment:
+        raise ValueError(f"Unsupported fragment '#{parsed_url.fragment}' in '{url}'")
+    if parsed_url.hostname is None:
+        raise ValueError(f"No host specified in '{url}'")
+    if parsed_url.port is None:
+        raise ValueError(f"No port number specified in '{url}'")
+
+    host = parsed_url.hostname
+    port = str(parsed_url.port)
+    if "[" in parsed_url.netloc and "]" in parsed_url.netloc:
+        # Preserve IPv6 address brackets
+        host = "[" + host + "]"
+
+    if parsed_url.scheme == "http":
+        return ServiceLocation(location=host, insecure_port=port, ssl_authenticated_port="")
+    else:
+        return ServiceLocation(location=host, insecure_port="", ssl_authenticated_port=port)
+
+
+def get_insecure_grpc_device_server_channel(
+    discovery_client: DiscoveryClient,
+    grpc_channel_pool: GrpcChannelPool,
+    provided_interface: str,
+) -> grpc.Channel | None:
+    """Get an unencrypted gRPC channel targeting NI gRPC Device Server."""
+    service_location = get_grpc_device_server_location(discovery_client, provided_interface)
+    if not service_location:
+        return None
+    if not service_location.insecure_port:
+        raise ValueError(f"No insecure port specified in {service_location!r}")
+    return grpc_channel_pool.get_channel(service_location.insecure_address)

ni/measurementlink/sessionmanagement/v1/client/_drivers/_nidaqmx.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any
+
+import nidaqmx
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: nidaqmx.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: nidaqmx.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: nidaqmx.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: nidaqmx.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: nidaqmx.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, nidaqmx.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> nidaqmx.Task:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = nidaqmx.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        return nidaqmx.Task(
+            new_task_name=session_info.session_name,
+            **kwargs,
+        )

ni/measurementlink/sessionmanagement/v1/client/_drivers/_nidcpower.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+import nidcpower
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    NIDCPOWER_OPTIONS,
+)
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: nidcpower.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: nidcpower.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: nidcpower.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: nidcpower.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: nidcpower.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        reset: bool,
+        options: dict[str, Any] | None,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, nidcpower.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._reset = reset
+        self._options = NIDCPOWER_OPTIONS.to_dict() if options is None else options
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> nidcpower.Session:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = nidcpower.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        return nidcpower.Session(
+            resource_name=session_info.resource_name,
+            reset=self._reset,
+            options=self._options,
+            **kwargs,
+        )

ni/measurementlink/sessionmanagement/v1/client/_drivers/_nidigital.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+import nidigital
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    NIDIGITAL_OPTIONS,
+)
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: nidigital.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: nidigital.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: nidigital.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: nidigital.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: nidigital.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        reset_device: bool,
+        options: dict[str, Any] | None,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, nidigital.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._reset_device = reset_device
+        self._options = NIDIGITAL_OPTIONS.to_dict() if options is None else options
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> nidigital.Session:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = nidigital.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        # Omit id_query because it has no effect.
+        return nidigital.Session(
+            resource_name=session_info.resource_name,
+            reset_device=self._reset_device,
+            options=self._options,
+            **kwargs,
+        )

ni/measurementlink/sessionmanagement/v1/client/_drivers/_nidmm.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+import nidmm
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    NIDMM_OPTIONS,
+)
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: nidmm.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: nidmm.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: nidmm.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: nidmm.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: nidmm.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        reset_device: bool,
+        options: dict[str, Any] | None,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, nidmm.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._reset_device = reset_device
+        self._options = NIDMM_OPTIONS.to_dict() if options is None else options
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> nidmm.Session:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = nidmm.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        # Omit id_query because it has no effect.
+        return nidmm.Session(
+            resource_name=session_info.resource_name,
+            reset_device=self._reset_device,
+            options=self._options,
+            **kwargs,
+        )

ni/measurementlink/sessionmanagement/v1/client/_drivers/_nifgen.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+import nifgen
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    NIFGEN_OPTIONS,
+)
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: nifgen.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: nifgen.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: nifgen.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: nifgen.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: nifgen.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        reset_device: bool,
+        options: dict[str, Any] | None,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, nifgen.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._reset_device = reset_device
+        self._options = NIFGEN_OPTIONS.to_dict() if options is None else options
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> nifgen.Session:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = nifgen.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        return nifgen.Session(
+            resource_name=session_info.resource_name,
+            reset_device=self._reset_device,
+            options=self._options,
+            **kwargs,
+        )

ni/measurementlink/sessionmanagement/v1/client/_drivers/_niscope.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+import niscope
+from ni.measurementlink.discovery.v1.client import DiscoveryClient
+from ni_grpc_extensions.channelpool import GrpcChannelPool
+
+from ni.measurementlink.sessionmanagement.v1.client._drivers._configuration import (
+    NISCOPE_OPTIONS,
+)
+from ni.measurementlink.sessionmanagement.v1.client._drivers._grpcdevice import (
+    get_insecure_grpc_device_server_channel,
+)
+from ni.measurementlink.sessionmanagement.v1.client._types import (
+    SessionInformation,
+    SessionInitializationBehavior,
+)
+
+_INITIALIZATION_BEHAVIOR = {
+    SessionInitializationBehavior.AUTO: niscope.SessionInitializationBehavior.AUTO,
+    SessionInitializationBehavior.INITIALIZE_SERVER_SESSION: niscope.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION: niscope.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+    SessionInitializationBehavior.INITIALIZE_SESSION_THEN_DETACH: niscope.SessionInitializationBehavior.INITIALIZE_SERVER_SESSION,
+    SessionInitializationBehavior.ATTACH_TO_SESSION_THEN_CLOSE: niscope.SessionInitializationBehavior.ATTACH_TO_SERVER_SESSION,
+}
+
+
+class SessionConstructor:
+    """Constructs sessions based on SessionInformation."""
+
+    def __init__(
+        self,
+        discovery_client: DiscoveryClient,
+        grpc_channel_pool: GrpcChannelPool,
+        reset_device: bool,
+        options: dict[str, Any] | None,
+        initialization_behavior: SessionInitializationBehavior,
+    ) -> None:
+        """Initialize the session constructor."""
+        self._grpc_channel = get_insecure_grpc_device_server_channel(
+            discovery_client, grpc_channel_pool, niscope.GRPC_SERVICE_INTERFACE_NAME
+        )
+        self._reset_device = reset_device
+        self._options = NISCOPE_OPTIONS.to_dict() if options is None else options
+        self._initialization_behavior = _INITIALIZATION_BEHAVIOR[initialization_behavior]
+
+    def __call__(self, session_info: SessionInformation) -> niscope.Session:
+        """Construct a session object."""
+        kwargs: dict[str, Any] = {}
+        if self._grpc_channel:
+            kwargs["grpc_options"] = niscope.GrpcSessionOptions(
+                grpc_channel=self._grpc_channel,
+                session_name=session_info.session_name,
+                initialization_behavior=self._initialization_behavior,
+            )
+
+        # Omit id_query because it has no effect.
+        return niscope.Session(
+            resource_name=session_info.resource_name,
+            reset_device=self._reset_device,
+            options=self._options,
+            **kwargs,
+        )