fixes per review notes, move poorly-placed class var declarations

smartsim/_core/launcher/dragon/dragonBackend.py

@@ -194,6 +194,17 @@ def __init__(self, pid: int) -> None:
         self._infra_ddict: t.Optional[dragon_ddict.DDict] = None
         self._prioritizer = NodePrioritizer(self._nodes, self._queue_lock)
 
+        self._nodes: t.List["dragon_machine.Node"] = []
+        """Node capability information for hosts in the allocation"""
+        self._hosts: t.List[str] = []
+        """List of hosts available in allocation"""
+        self._cpus: t.List[int] = []
+        """List of cpu-count by node"""
+        self._gpus: t.List[int] = []
+        """List of gpu-count by node"""
+        self._allocated_hosts: t.Dict[str, t.Set[str]] = {}
+        """Mapping with hostnames as keys and a set of running step IDs as the value"""
+
     @property
     def hosts(self) -> list[str]:
         with self._queue_lock:
@@ -229,16 +240,10 @@ def _initialize_hosts(self) -> None:
             self._nodes = [
                 dragon_machine.Node(node) for node in dragon_machine.System().nodes
             ]
-            self._hosts: t.List[str] = sorted(node.hostname for node in self._nodes)
-            """List of hosts available in allocation"""
+            self._hosts = sorted(node.hostname for node in self._nodes)
             self._cpus = [node.num_cpus for node in self._nodes]
-            """List of cpu-count by node"""
             self._gpus = [node.num_gpus for node in self._nodes]
-            """List of gpu-count by node"""
-            self._allocated_hosts: t.Dict[str, t.Set[str]] = collections.defaultdict(
-                set
-            )
-            """Mapping with hostnames as keys and a set of executing step IDs as the value"""
+            self._allocated_hosts = collections.defaultdict(set)
 
     def __str__(self) -> str:
         return self.status_message

smartsim/_core/launcher/dragon/pqueue.py

@@ -124,7 +124,8 @@ def add(
         reference counted.
 
         :param tracking_id: a unique task identifier executing on the node
-        to add"""
+        to add
+        :raises ValueError: if tracking_id is already assigned to this node"""
         if tracking_id in self.assigned_tasks:
             raise ValueError("Attempted adding task more than once")
 
@@ -140,7 +141,8 @@ def remove(
         """Update the reference counter to indicate the removal of a process.
 
         :param tracking_id: a unique task identifier executing on the node
-        to remove"""
+        to remove
+        :raises ValueError: if tracking_id is already assigned to this node"""
         if tracking_id and tracking_id not in self.assigned_tasks:
             raise ValueError("Attempted removal of untracked item")
 
@@ -335,12 +337,12 @@ def _check_satisfiable_n(
 
         return True
 
-    def _get_next_available_node(
+    def _get_next_unassigned_node(
         self,
         heap: t.List[_TrackedNode],
         tracking_id: t.Optional[str] = None,
     ) -> t.Optional[Node]:
-        """Finds the next node w/the least amount of running processes and
+        """Finds the next node with no running processes and
         ensures that any elements that were directly updated are updated in
         the priority structure before being made available
 
@@ -402,7 +404,7 @@ def _get_next_n_available_nodes(
             return next_nodes
 
         while len(next_nodes) < num_items:
-            if next_node := self._get_next_available_node(heap, tracking_id):
+            if next_node := self._get_next_unassigned_node(heap, tracking_id):
                 next_nodes.append(next_node)
                 continue
             break
@@ -430,7 +432,7 @@ def next(
         tracking_id: t.Optional[str] = None,
         hosts: t.Optional[t.List[str]] = None,
     ) -> t.Optional[Node]:
-        """Find the next available node using the supplied filter to target
+        """Find the next unsassigned node using the supplied filter to target
         a specific node capability
 
         :param filter_on: the subset of nodes to query for available nodes
@@ -456,9 +458,10 @@ def next_n(
         :param filter_on: the subset of nodes to query for available nodes
         :param tracking_id: unique task identifier to track
         :param hosts: a list of hostnames used to filter the available nodes
-        :returns: Collection of reserved nodes"""
+        :returns: Collection of reserved nodes
+        :raises ValueError: if the hosts parameter is an empty list"""
         if hosts is not None and not hosts:
-            raise ValueError("No host names provided")
+            raise ValueError("No hostnames provided")
 
         heap = self._create_sub_heap(hosts, filter_on)
         return self._get_next_n_available_nodes(num_items, heap, tracking_id)

smartsim/settings/dragonRunSettings.py

@@ -100,6 +100,7 @@ def set_hostlist(self, host_list: t.Union[str, t.List[str]]) -> None:
         """Specify the hostlist for this job
 
         :param host_list: hosts to launch on
+        :raises ValueError: if an empty host list is supplied
         """
         if not host_list:
             raise ValueError("empty hostlist provided")