Add default value to nislsc python api

examples/check_chassis_battery.py

@@ -22,30 +22,25 @@ def main(chassis_name: str) -> None:
     """  # noqa: D301
     try:
         physical_channel_names = f"{chassis_name}/BatteryVoltageSensor"
-        connection_timeout = 10.0
         reservation_access = ReservationAccess.READ_ONLY
         reservation_group = "admin"
-        reservation_timeout = 10.0
 
         with Session.initialize_session_with_physical_channels(
-            None,
             physical_channel_names=physical_channel_names,
-            connection_timeout=connection_timeout,
             reservation_access=reservation_access,
             reservation_group=reservation_group,
-            reservation_timeout=reservation_timeout,
         ) as session:
             sensor_lower_critical = session.get_physical_channel_property_double(
-                physical_channel_names=physical_channel_names,
                 property_name="SensorLowerCritical",
+                physical_channel_names=physical_channel_names,
             )
             sensor_reading = session.get_physical_channel_property_double(
-                physical_channel_names=physical_channel_names,
                 property_name="SensorReading",
+                physical_channel_names=physical_channel_names,
             )
             health_state = session.get_physical_channel_property_string(
-                physical_channel_names=physical_channel_names,
                 property_name="HealthState",
+                physical_channel_names=physical_channel_names,
             )
             needs_replacement = sensor_reading < sensor_lower_critical
 

examples/reset_device.py

@@ -22,18 +22,13 @@ def main(device_names: str) -> None:
         reset_device SLSC-12001-XXXXXXXX-Mod1,SLSC-12001-XXXXXXXX-Mod2
     """  # noqa: D301
     try:
-        connection_timeout = 10.0
         reservation_access = ReservationAccess.READ_ONLY
         reservation_group = "admin"
-        reservation_timeout = 10.0
 
         with Session.initialize_session_with_devices(
-            None,
             device_names=device_names,
-            connection_timeout=connection_timeout,
             reservation_access=reservation_access,
             reservation_group=reservation_group,
-            reservation_timeout=reservation_timeout,
         ) as session:
             session.reset_devices(device_names)
             print(f"Reset command sent to device(s) {device_names}")

examples/show_command_and_property_tree.py

@@ -49,18 +49,13 @@ def get_command_and_property_tree(device_name: str) -> dict:
     Returns:
         Dictionary containing the command and property tree of the device.
     """
-    connection_timeout = 10.0
     reservation_access = ReservationAccess.READ_ONLY
     reservation_group = "admin"
-    reservation_timeout = 10.0
 
     with Session.initialize_session_with_devices(
-        None,
-        device_name,
-        connection_timeout,
-        reservation_access,
-        reservation_group,
-        reservation_timeout,
+        device_names=device_name,
+        reservation_access=reservation_access,
+        reservation_group=reservation_group,
     ) as session:
 
         data = {

generated/nislsc/constants.py

@@ -15,6 +15,26 @@
         class StrEnum(str, Enum):
             """StrEnum fallback for Python versions < 3.11."""
 
+CONNECTED_DEVICES_ALIAS = "$ConnectedDevices"
+"""A resource alias representing the session's connected devices."""
+
+DEFAULT_DEVICES_ALIAS = "$DefaultDevices"
+"""A resource alias representing the session's default devices."""
+
+DEFAULT_NVMEM_AREAS_ALIAS = "$DefaultNVMEMAreas"
+"""A resource alias representing the session's default NVMEM areas."""
+
+DEFAULT_PHYS_CHANS_ALIAS = "$DefaultPhysChans"
+"""A resource alias representing the session's default physical channels."""
+
+RESERVED_DEVICES_ALIAS = "$ReservedDevices"
+"""A resource alias representing the session's reserved devices."""
+
+SESSION_ALIAS = "$Session"
+"""A resource alias for accessing session properties."""
+
+SYSTEM_ALIAS = "$System"
+"""A resource alias for accessing system properties."""
 
 class ReservationAccess(Enum):
     """Define SLSC reservation access modes."""

generated/nislsc/session.py

@@ -67,7 +67,7 @@ def close(self) -> None:
             self._owns_library = False
 
     @classmethod
-    def initialize_session_with_devices(cls, library: Library | None, device_names: str, connection_timeout: float, reservation_access: ReservationAccess, reservation_group: str, reservation_timeout: float) -> Self:
+    def initialize_session_with_devices(cls, device_names: str, library: Library | None = None, connection_timeout: float = -1.0, reservation_access: ReservationAccess = ReservationAccess.READ_WRITE, reservation_group: str = '', reservation_timeout: float = -1.0) -> Self:
         """Initialize an SLSC session with one or multiple devices.
 
         The session opens network connections for devices. If reservationAccess
@@ -110,7 +110,7 @@ def initialize_session_with_devices(cls, library: Library | None, device_names:
         return cls(library, session_handle, owns_library)
 
     @classmethod
-    def initialize_session_with_nvmem_areas(cls, library: Library | None, nvmem_area_names: str, connection_timeout: float, reservation_access: ReservationAccess, reservation_group: str, reservation_timeout: float) -> Self:
+    def initialize_session_with_nvmem_areas(cls, nvmem_area_names: str, library: Library | None = None, connection_timeout: float = -1.0, reservation_access: ReservationAccess = ReservationAccess.READ_WRITE, reservation_group: str = '', reservation_timeout: float = -1.0) -> Self:
         """Initialize an SLSC session with one or multiple NVMEM areas.
 
         The session opens network connections for NVMEM areas. If
@@ -155,7 +155,7 @@ def initialize_session_with_nvmem_areas(cls, library: Library | None, nvmem_area
         return cls(library, session_handle, owns_library)
 
     @classmethod
-    def initialize_session_with_physical_channels(cls, library: Library | None, physical_channel_names: str, connection_timeout: float, reservation_access: ReservationAccess, reservation_group: str, reservation_timeout: float) -> Self:
+    def initialize_session_with_physical_channels(cls, physical_channel_names: str, library: Library | None = None, connection_timeout: float = -1.0, reservation_access: ReservationAccess = ReservationAccess.READ_WRITE, reservation_group: str = '', reservation_timeout: float = -1.0) -> Self:
         """Initialize an SLSC session with one or multiple physical channels.
 
         The session opens network connections for devices that correspond to the
@@ -203,7 +203,7 @@ def initialize_session_with_physical_channels(cls, library: Library | None, phys
         return cls(library, session_handle, owns_library)
 
     @classmethod
-    def initialize_session_without_resources(cls, library: Library | None) -> Self:
+    def initialize_session_without_resources(cls, library: Library | None = None) -> Self:
         """Initialize an SLSC session without specifying any resources or
         opening any network connections.
 
@@ -239,7 +239,7 @@ def abort_session(self) -> None:
         """
         self._interpreter.abort_session(self._session_handle)
 
-    def log_in(self, chassis_name: str, username: str, password: str, connection_timeout: float, save_credentials_to_disk: bool) -> None:
+    def log_in(self, chassis_name: str, username: str, password: str, save_credentials_to_disk: bool, connection_timeout: float = -1.0) -> None:
         """Attempt to connect and log in to the specified SLSC chassis.
 
         If successful, the username and password are cached on the local system
@@ -297,7 +297,7 @@ def log_out(self, chassis_name: str) -> None:
         """
         self._interpreter.log_out(self._session_handle, chassis_name)
 
-    def connect_to_devices(self, device_names: str, connection_timeout: float) -> None:
+    def connect_to_devices(self, device_names: str = '$DefaultDevices', connection_timeout: float = -1.0) -> None:
         """Open network connections for the specified device(s), sharing
         connections to the same SLSC chassis.
 
@@ -318,7 +318,7 @@ def connect_to_devices(self, device_names: str, connection_timeout: float) -> No
         """
         self._interpreter.connect_to_devices(self._session_handle, device_names, connection_timeout)
 
-    def disconnect_from_devices(self, device_names: str) -> None:
+    def disconnect_from_devices(self, device_names: str = '$DefaultDevices') -> None:
         """Close network connections for the specified devices.
 
         When multiple devices share a network connection because they are in the
@@ -332,7 +332,7 @@ def disconnect_from_devices(self, device_names: str) -> None:
         """
         self._interpreter.disconnect_from_devices(self._session_handle, device_names)
 
-    def connect_to_chassis_by_address(self, address: str, username: str, password: str, connection_timeout: float) -> str:
+    def connect_to_chassis_by_address(self, address: str, username: str, password: str, connection_timeout: float = -1.0) -> str:
         """Open a network connection for a chassis by the specified IP address
         or hostname.
 
@@ -353,7 +353,7 @@ def connect_to_chassis_by_address(self, address: str, username: str, password: s
         chassis_name = self._interpreter.connect_to_chassis_by_address(self._session_handle, address, username, password, connection_timeout)
         return chassis_name
 
-    def reserve_devices(self, device_names: str, reservation_access: ReservationAccess, reservation_group: str, reservation_timeout: float) -> None:
+    def reserve_devices(self, device_names: str = '$DefaultDevices', reservation_access: ReservationAccess = ReservationAccess.READ_WRITE, reservation_group: str = '', reservation_timeout: float = -1.0) -> None:
         """Reserve the specified device(s), which prevents other sessions from
         accessing them.
 
@@ -379,7 +379,7 @@ def reserve_devices(self, device_names: str, reservation_access: ReservationAcce
         """
         self._interpreter.reserve_devices(self._session_handle, device_names, reservation_access, reservation_group, reservation_timeout)
 
-    def unreserve_devices(self, device_names: str) -> None:
+    def unreserve_devices(self, device_names: str = '$DefaultDevices') -> None:
         """Unreserve the specified device(s), allowing other sessions to access
         them.
 
@@ -390,7 +390,7 @@ def unreserve_devices(self, device_names: str) -> None:
         """
         self._interpreter.unreserve_devices(self._session_handle, device_names)
 
-    def reset_devices(self, device_names: str) -> None:
+    def reset_devices(self, device_names: str = '$DefaultDevices') -> None:
         """Reset the specified device(s) to the default state.
 
         This function sends the specified devices a hardware reset signal,
@@ -425,7 +425,7 @@ def rename_device(self, device_name: str, new_device_name: str) -> None:
         """
         self._interpreter.rename_device(self._session_handle, device_name, new_device_name)
 
-    def update_system_configuration_file(self, chassis_name: str, connection_timeout: float) -> None:
+    def update_system_configuration_file(self, chassis_name: str, connection_timeout: float = -1.0) -> None:
         """Update the information of the specified chassis and its modules in
         the local configuration file.
 
@@ -442,7 +442,7 @@ def update_system_configuration_file(self, chassis_name: str, connection_timeout
         """
         self._interpreter.update_system_configuration_file(self._session_handle, chassis_name, connection_timeout)
 
-    def add_network_chassis(self, address: str, username: str, password: str, connection_timeout: float) -> str:
+    def add_network_chassis(self, address: str, username: str, password: str, connection_timeout: float = -1.0) -> str:
         """Connect to the specified network chassis, adds the chassis and its
         modules to the system, and saves them to the local configuration file.
 
@@ -1668,7 +1668,7 @@ def set_physical_channel_property_uint64_array(self, physical_channel_names: str
         """
         self._interpreter.set_physical_channel_property_uint64_array(self._session_handle, physical_channel_names, property_name, property_value)
 
-    def commit_properties_for_devices(self, device_names: str) -> None:
+    def commit_properties_for_devices(self, device_names: str = '$DefaultDevices') -> None:
         """Commit all device or physical channels properties with pending
         changes to hardware for the specified device(s) and the physical
         channels that they contain.
@@ -1683,7 +1683,7 @@ def commit_properties_for_devices(self, device_names: str) -> None:
         """
         self._interpreter.commit_properties_for_devices(self._session_handle, device_names)
 
-    def commit_properties_for_physical_channels(self, physical_channel_names: str) -> None:
+    def commit_properties_for_physical_channels(self, physical_channel_names: str = '$DefaultPhysChans') -> None:
         """Commit all physical channel properties with pending changes to
         hardware for the specified physical channel(s).
 
@@ -2514,7 +2514,7 @@ def set_generic_property_uint64_array(self, resources: str, property_name: str,
         """
         self._interpreter.set_generic_property_uint64_array(self._session_handle, resources, property_name, property_value)
 
-    def execute_device_command(self, device_names: str, command_name: str, timeout: float) -> None:
+    def execute_device_command(self, command_name: str, timeout: float, device_names: str = '$DefaultDevices') -> None:
         """Execute the specified device command on one or more devices.
 
         Commands define how user applications initiate actions or coordinated
@@ -2538,7 +2538,7 @@ def execute_device_command(self, device_names: str, command_name: str, timeout:
         """
         self._interpreter.execute_device_command(self._session_handle, device_names, command_name, timeout)
 
-    def execute_physical_channel_command(self, physical_channel_names: str, command_name: str, timeout: float) -> None:
+    def execute_physical_channel_command(self, command_name: str, timeout: float, physical_channel_names: str = '$DefaultPhysChans') -> None:
         """Execute the specified physical channel command on one or more
         physical channels.
 
@@ -2588,7 +2588,7 @@ def execute_generic_command(self, resources: str, command_name: str, timeout: fl
         """
         self._interpreter.execute_generic_command(self._session_handle, resources, command_name, timeout)
 
-    def read_register_uint8(self, device_name: str, register_address: int) -> int:
+    def read_register_uint8(self, register_address: int, device_name: str = '$DefaultDevices') -> int:
         """Read the specified register.
 
         To read a single bitfield, consider using properties instead.
@@ -2607,7 +2607,7 @@ def read_register_uint8(self, device_name: str, register_address: int) -> int:
         data = self._interpreter.read_register_uint8(self._session_handle, device_name, register_address)
         return data
 
-    def read_register_uint16(self, device_name: str, register_address: int) -> int:
+    def read_register_uint16(self, register_address: int, device_name: str = '$DefaultDevices') -> int:
         """Read the specified register.
 
         To read a single bitfield, consider using properties instead.
@@ -2626,7 +2626,7 @@ def read_register_uint16(self, device_name: str, register_address: int) -> int:
         data = self._interpreter.read_register_uint16(self._session_handle, device_name, register_address)
         return data
 
-    def read_register_uint32(self, device_name: str, register_address: int) -> int:
+    def read_register_uint32(self, register_address: int, device_name: str = '$DefaultDevices') -> int:
         """Read the specified register.
 
         To read a single bitfield, consider using properties instead.
@@ -2645,7 +2645,7 @@ def read_register_uint32(self, device_name: str, register_address: int) -> int:
         data = self._interpreter.read_register_uint32(self._session_handle, device_name, register_address)
         return data
 
-    def read_register_uint64(self, device_name: str, register_address: int) -> int:
+    def read_register_uint64(self, register_address: int, device_name: str = '$DefaultDevices') -> int:
         """Read the specified register.
 
         To read a single bitfield, consider using properties instead.
@@ -2664,7 +2664,7 @@ def read_register_uint64(self, device_name: str, register_address: int) -> int:
         data = self._interpreter.read_register_uint64(self._session_handle, device_name, register_address)
         return data
 
-    def write_register_uint8(self, device_name: str, register_address: int, data: int) -> None:
+    def write_register_uint8(self, register_address: int, data: int, device_name: str = '$DefaultDevices') -> None:
         """Write data to the specified register.
 
         To write a single bitfield, consider using properties instead.
@@ -2680,7 +2680,7 @@ def write_register_uint8(self, device_name: str, register_address: int, data: in
         """
         self._interpreter.write_register_uint8(self._session_handle, device_name, register_address, data)
 
-    def write_register_uint16(self, device_name: str, register_address: int, data: int) -> None:
+    def write_register_uint16(self, register_address: int, data: int, device_name: str = '$DefaultDevices') -> None:
         """Write data to the specified register.
 
         To write a single bitfield, consider using properties instead.
@@ -2696,7 +2696,7 @@ def write_register_uint16(self, device_name: str, register_address: int, data: i
         """
         self._interpreter.write_register_uint16(self._session_handle, device_name, register_address, data)
 
-    def write_register_uint32(self, device_name: str, register_address: int, data: int) -> None:
+    def write_register_uint32(self, register_address: int, data: int, device_name: str = '$DefaultDevices') -> None:
         """Write data to the specified register.
 
         To write a single bitfield, consider using properties instead.
@@ -2712,7 +2712,7 @@ def write_register_uint32(self, device_name: str, register_address: int, data: i
         """
         self._interpreter.write_register_uint32(self._session_handle, device_name, register_address, data)
 
-    def write_register_uint64(self, device_name: str, register_address: int, data: int) -> None:
+    def write_register_uint64(self, register_address: int, data: int, device_name: str = '$DefaultDevices') -> None:
         """Write data to the specified register.
 
         To write a single bitfield, consider using properties instead.
@@ -2764,7 +2764,7 @@ def set_nvmem_bytes(self, nvmem_area: str, nvmem_address: int, bytes_data: bytes
         """
         self._interpreter.set_nvmem_bytes(self._session_handle, nvmem_area, nvmem_address, bytes_data, serial_number, password)
 
-    def commit_nvmem_areas(self, nvmem_area_names: str) -> None:
+    def commit_nvmem_areas(self, nvmem_area_names: str = '$DefaultNVMEMAreas') -> None:
         """Commit pending changes to hardware for the specified NVMEM area(s).
 
         Args:
@@ -2774,7 +2774,7 @@ def commit_nvmem_areas(self, nvmem_area_names: str) -> None:
         """
         self._interpreter.commit_nvmem_areas(self._session_handle, nvmem_area_names)
 
-    def commit_nvmem_for_devices(self, device_names: str) -> None:
+    def commit_nvmem_for_devices(self, device_names: str = '$DefaultDevices') -> None:
         """Commit pending changes to hardware for all NVMEM areas on the
         specified device(s).