yellowdog-python-examples 7.19.7__tar.gz → 7.20.0__tar.gz

{yellowdog_python_examples-7.19.7 → yellowdog_python_examples-7.20.0}/PKG-INFO

@@ -1,13 +1,19 @@
 Metadata-Version: 2.4
 Name: yellowdog-python-examples
-Version: 7.19.7
+Version: 7.20.0
 Summary: Python CLI commands using the YellowDog Python SDK
 Author-email: YellowDog Limited <support@yellowdog.co>
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/yellowdog/python-examples
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.7
-Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.7
@@ -20,7 +26,7 @@ Requires-Dist: requests
 Requires-Dist: rich==13.9.4
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: toml
-Requires-Dist: yellowdog-sdk>=10.0.0
+Requires-Dist: yellowdog-sdk>=11.2.0
 Provides-Extra: jsonnet
 Requires-Dist: jsonnet; extra == "jsonnet"
 Provides-Extra: cloudwizard

{yellowdog_python_examples-7.19.7 → yellowdog_python_examples-7.20.0}/README.md

@@ -602,7 +602,8 @@ All properties are optional except for **`taskType`** (or **`taskTypes`**).
 | `completedTaskTtl`          | The time (in minutes) to live for completed Tasks. If set, Tasks that have been completed for longer than this period will be deleted. E.g.: `10.0`.                                                                                       | Yes  | Yes | Yes  |      |
 | `csvFile`                   | The name of the CSV file used to derive Task data. An alternative to `csvFiles` that can be used when there's only a single CSV file. E.g. `"file.csv"`.                                                                                   | Yes  |     |      |      |
 | `csvFiles`                  | A list of CSV files used to derive Task data. E.g. `["file.csv", "file_2.csv:2]`.                                                                                                                                                          | Yes  |     |      |      |
-| `dependentOn`               | The name of another Task Group within the same Work Requirement that must be successfully completed before the Task Group is started. E.g. `"task_group_1"`.                                                                               |      |     | Yes  |      |
+| `dependencies`              | The names of other Task Groups within the same Work Requirement that must be successfully completed before the Task Group is started. E.g. `["task_group_1", "task_group_2"]`.                                                             |      |     | Yes  |      |
+| `dependentOn`               | [Deprecated in favour of `dependencies`] The name of another Task Group within the same Work Requirement that must be successfully completed before the Task Group is started. E.g. `"task_group_1"`.                                      |      |     | Yes  |      |
 | `dockerEnvironment`         | The environment to be passed to a Docker container. Only used by the `docker` Task Type. E.g., JSON: `{"VAR_1": "abc"}`, TOML: `{VAR_1 = "abc", VAR_2 = "def"}`.                                                                           | Yes  | Yes | Yes  | Yes  |
 | `dockerOptions`             | Additional options to be passed to the docker run command. Only used by the `docker` Task Type. E.g.,`["--runtime nvidia, "--gpus all"]`.                                                                                                  | Yes  | Yes | Yes  | Yes  |
 | `dockerPassword`            | The password for the Docker container registry; only used by the `docker` Task Type. E,g., `"my_password"`.                                                                                                                                | Yes  | Yes | Yes  | Yes  |
@@ -1017,7 +1018,7 @@ Showing all possible properties at the Task Group level:
     },
     {
       "name": "second-task-group",
-      "dependentOn": "first-task-group",
+      "dependencies": ["first-task-group"],
       "tasks": [
         {}
       ]

{yellowdog_python_examples-7.19.7 → yellowdog_python_examples-7.20.0}/pyproject.toml

@@ -9,12 +9,18 @@
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.7",
-        "License :: OSI Approved :: Apache Software License",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
         "Operating System :: OS Independent",
         "Development Status :: 4 - Beta",
     ]
     requires-python = ">=3.7"
     dynamic = ["version", "dependencies"]
+    license = "Apache-2.0"
 
 [[project.authors]]
     name = "YellowDog Limited"

{yellowdog_python_examples-7.19.7 → yellowdog_python_examples-7.20.0}/requirements.txt

@@ -5,4 +5,4 @@ requests
 rich == 13.9.4
 tabulate >= 0.9.0
 toml
-yellowdog-sdk >= 10.0.0
+yellowdog-sdk >= 11.2.0

yellowdog_python_examples-7.20.0/yellowdog_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "7.20.0"

{yellowdog_python_examples-7.19.7 → yellowdog_python_examples-7.20.0}/yellowdog_cli/compare.py

@@ -1,21 +1,24 @@
 #!/usr/bin/env python3
 
 """
-A script to compare work requirements and task groups with worker pools,
-and check for matches.
+A script to compare work requirements and task groups with provisioned worker pools,
+and to check for matches.
 """
 
 from dataclasses import dataclass
 from enum import Enum
 from functools import cache
-from typing import List, Optional
+from typing import List, Optional, Set
 
 from tabulate import tabulate
 from yellowdog_client.model import (
+    ComputeRequirement,
+    ComputeSource,
     DoubleRange,
     Node,
     NodeSearch,
     NodeStatus,
+    ProvisionedWorkerPool,
     TaskGroup,
     WorkerPool,
     WorkRequirement,
@@ -33,14 +36,19 @@ from yellowdog_cli.utils.ydid_utils import YDIDType, get_ydid_type
 
 NONE_STRING = "NONE"
 EMPTY_STRING = ""
-UNKNOWN_STRING = "NOT YET KNOWN"
+UNKNOWN_STRING = "NOT CURRENTLY KNOWN"
+
+AWS = "AWS"
+AZURE = "AZURE"
+GCE = "GCE"
+GOOGLE = "GOOGLE"
+OCI = "OCI"
 
 
 class MatchType(Enum):
     YES = "YES"  # Definite match to the worker pool (so far)
     NO = "NO"  # Definite non-match to the worker pool
     MAYBE = "MAYBE (no Nodes available)"  # Possible match to the worker pool; no nodes available
-    PARTIAL = "PARTIAL (one or more Nodes match, but not all)"  # Some nodes in the worker pool match
 
 
 @dataclass
@@ -85,14 +93,14 @@ class MatchReport:
         self._ram = ram
         self._vcpus = vcpus
         self._property_match_list = [
-            self._worker_tags,
-            self._namespaces,
             self._instance_types,
+            self._namespaces,
             self._providers,
             self._ram,
             self._regions,
             self._task_types,
             self._vcpus,
+            self._worker_tags,
         ]
 
     @cache
@@ -106,12 +114,6 @@ class MatchReport:
         elif any(p.match == MatchType.NO for p in self._property_match_list):
             return MatchType.NO
 
-        elif all(
-            p.match == MatchType.YES or p.match == MatchType.PARTIAL
-            for p in self._property_match_list
-        ):
-            return MatchType.PARTIAL
-
         elif all(
             p.match == MatchType.YES or p.match == MatchType.MAYBE
             for p in self._property_match_list
@@ -119,7 +121,7 @@ class MatchReport:
             return MatchType.MAYBE
 
         # Shouldn't get here
-        print_warning("Unable to calculate YES/PARTIAL/MAYBE/NO summary")
+        print_warning("Unable to calculate YES/MAYBE/NO summary")
         return MatchType.NO
 
     def print_detailed_report(self):
@@ -130,12 +132,10 @@ class MatchReport:
             match_str = "MATCHING"
         elif self.summary() == MatchType.MAYBE:
             match_str = "MAYBE MATCHING"
-        elif self.summary() == MatchType.PARTIAL:
-            match_str = "PARTIALLY MATCHING"
         else:
             match_str = "NON-MATCHING"
         print_log(
-            f"Detailed comparison report for {match_str} ({self.worker_pool_status}) worker pool "
+            f"Detailed comparison report for {match_str} ({self.worker_pool_status}) Worker Pool "
             f"'{self.worker_pool_name}' ({self.worker_pool_id})",
             override_quiet=True,
         )
@@ -144,7 +144,7 @@ class MatchReport:
         header_row = [
             "Property",
             "Task Group Run Specification",
-            "Worker Pool Nodes/Workers",
+            "Worker Pool",
             "Match Status",
         ]
         table_rows = []
@@ -179,7 +179,7 @@ class WorkerPools:
     Populates once for each run of the script.
     """
 
-    def __init__(self, worker_pools: List[WorkerPool]):
+    def __init__(self, worker_pools: List[ProvisionedWorkerPool]):
         self._populated = False
         self._worker_pools = worker_pools
 
@@ -215,9 +215,59 @@ class WorkerPools:
             vcpus=self._match_vcpus(task_group, worker_pool),
         )
 
+    def _get_providers(self, worker_pool: ProvisionedWorkerPool) -> Set[str]:
+        return {
+            self._get_provider_from_source(source)
+            for source in self._get_cr_from_wp(worker_pool).provisionStrategy.sources
+        }
+
+    def _get_regions(self, worker_pool: ProvisionedWorkerPool) -> Set[str]:
+        return {
+            source.region
+            for source in self._get_cr_from_wp(worker_pool).provisionStrategy.sources
+        }
+
+    def _get_instance_types(self, worker_pool: ProvisionedWorkerPool) -> Set[str]:
+        instance_types = set()
+        for source in self._get_cr_from_wp(worker_pool).provisionStrategy.sources:
+            provider = self._get_provider_from_source(source)
+            if provider == AWS:
+                instance_types.add(source.instanceType)
+                try:  # Only for Fleet sources
+                    for override in source.instanceOverrides:
+                        instance_types.add(override.instanceType)
+                except:
+                    pass
+            # ToDo: Add similar checks for the fleet equivalents
+            elif provider == AZURE:
+                instance_types.add(source.vmSize)
+            elif provider == GOOGLE:
+                instance_types.add(source.machineType)
+            elif provider == OCI:
+                instance_types.add(source.shape)
+        return instance_types
+
+    @staticmethod
+    def _get_cr_from_wp(worker_pool: ProvisionedWorkerPool) -> ComputeRequirement:
+        return CLIENT.compute_client.get_compute_requirement_by_id(
+            worker_pool.computeRequirementId
+        )
+
+    @staticmethod
+    def _get_provider_from_source(source: ComputeSource) -> Optional[str]:
+        if AWS.lower() in source.type.lower():
+            return AWS
+        elif AZURE.lower() in source.type.lower():
+            return AZURE
+        elif GCE.lower() in source.type.lower():
+            return GOOGLE
+        elif OCI.lower() in source.type.lower():
+            return OCI
+        return None
+
     @staticmethod
     def _match_worker_tags(
-        task_group: TaskGroup, worker_pool: WorkerPool
+        task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         return PropertyMatch(
             property_name="Worker Tag(s)",
@@ -244,63 +294,44 @@ class WorkerPools:
         )
 
     def _match_instance_types(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         runspec_instance_types = (
             set()
             if task_group.runSpecification.instanceTypes is None
             else set(task_group.runSpecification.instanceTypes)
         )
-        nodes = self._get_all_nodes_in_worker_pool(worker_pool)
-        node_instance_types = {
-            node.details.instanceType
-            for node in nodes
-            if node.details.instanceType != ""
-        }
+
+        worker_pool_instance_types = self._get_instance_types(worker_pool)
         worker_pool_values = (
-            EMPTY_STRING
-            if len(nodes) == 0
-            else (
-                ", ".join(node_instance_types)
-                if len(node_instance_types) > 0
-                else NONE_STRING
-            )
+            ", ".join(sorted(list(worker_pool_instance_types)))
+            if len(worker_pool_instance_types) > 0
+            else NONE_STRING
         )
 
-        # Calculate match
-        matching_nodes_counter = 0
-        if len(runspec_instance_types) == 0:
+        # Calculate match: the instance types in the worker pool must be
+        # a subset of those in the run specification
+        if (
+            len(runspec_instance_types) == 0
+            or worker_pool_instance_types <= runspec_instance_types
+        ):
             match_type = MatchType.YES
-        elif len(nodes) == 0:
-            match_type = MatchType.MAYBE
         else:
-            for node in nodes:
-                if node.details.instanceType in runspec_instance_types:
-                    matching_nodes_counter += 1
-            if matching_nodes_counter == 0:
-                match_type = MatchType.NO
-            elif matching_nodes_counter < len(nodes):
-                match_type = MatchType.PARTIAL
-            else:
-                match_type = MatchType.YES
+            match_type = MatchType.NO
 
         return PropertyMatch(
             property_name="Instance Type(s)",
             task_group_values=(
                 EMPTY_STRING
                 if task_group.runSpecification.instanceTypes is None
-                else ", ".join(task_group.runSpecification.instanceTypes)
+                else ", ".join(sorted(task_group.runSpecification.instanceTypes))
             ),
             worker_pool_values=worker_pool_values,
             match=match_type,
-            match_count=(
-                matching_nodes_counter if len(runspec_instance_types) > 0 else None
-            ),
-            total_nodes=len(nodes) if len(runspec_instance_types) > 0 else None,
         )
 
     def _match_task_types(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         runspec_task_types = (
             set()
@@ -308,149 +339,108 @@ class WorkerPools:
             else set(task_group.runSpecification.taskTypes)
         )
         nodes = self._get_all_nodes_in_worker_pool(worker_pool)
-        node_task_types = set(
-            [
-                task_type
-                for node in nodes
-                for task_type in node.details.supportedTaskTypes
-            ]
-        )
+        if len(nodes) > 0:
+            node_task_types = set(nodes[0].details.supportedTaskTypes)
+        else:
+            node_task_types = set()
 
         worker_pool_values = (
             UNKNOWN_STRING
             if len(nodes) == 0
             else (
-                ", ".join(node_task_types) if len(node_task_types) > 0 else NONE_STRING
+                ", ".join(sorted(list(node_task_types)))
+                if len(node_task_types) > 0
+                else NONE_STRING
             )
         )
 
-        # Calculate match
-        matching_node_counter = 0
+        # Calculate match: the task types in the worker pool must include
+        # all of those in the run specification. The scheduler calculates
+        # this based on what the first node reports, but we have to take
+        # a node that possibly is not the first.
         if len(nodes) == 0:
             match_type = MatchType.MAYBE
+        elif runspec_task_types <= node_task_types:
+            match_type = MatchType.YES
         else:
-            for node in nodes:
-                if runspec_task_types <= set(node.details.supportedTaskTypes):
-                    matching_node_counter += 1
-            if matching_node_counter == 0:
-                match_type = MatchType.NO
-            elif matching_node_counter < len(nodes):
-                match_type = MatchType.PARTIAL
-            else:
-                match_type = MatchType.YES
+            match_type = MatchType.NO
 
         return PropertyMatch(
             property_name="Task Type(s)",
             task_group_values=(
                 NONE_STRING
                 if task_group.runSpecification.taskTypes is None
-                else ", ".join(task_group.runSpecification.taskTypes)
+                else ", ".join(sorted(task_group.runSpecification.taskTypes))
             ),
             worker_pool_values=worker_pool_values,
             match=match_type,
-            match_count=matching_node_counter,
-            total_nodes=len(nodes),
         )
 
     def _match_providers(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         runspec_providers = (
             set()
             if task_group.runSpecification.providers is None
-            else set(task_group.runSpecification.providers)
+            else {provider.value for provider in task_group.runSpecification.providers}
         )
-        nodes = self._get_all_nodes_in_worker_pool(worker_pool)
-        node_providers = {node.details.provider.value for node in nodes}
+        worker_pool_providers = self._get_providers(worker_pool)
 
-        # Calculate match
-        matching_node_counter = 0
-        if len(runspec_providers) == 0:
+        # Calculate match: the providers in the worker pool must be
+        # a subset of those in the run specification
+        if len(runspec_providers) == 0 or worker_pool_providers <= runspec_providers:
             match_type = MatchType.YES
-        elif len(nodes) == 0:
-            match_type = MatchType.MAYBE
         else:
-            for node in nodes:
-                if node.details.provider in runspec_providers:
-                    matching_node_counter += 1
-            if matching_node_counter == 0:
-                match_type = MatchType.NO
-            elif matching_node_counter < len(nodes):
-                match_type = MatchType.PARTIAL
-            else:
-                match_type = MatchType.YES
+            match_type = MatchType.NO
 
         return PropertyMatch(
             property_name="Provider(s)",
             task_group_values=(
                 EMPTY_STRING
                 if task_group.runSpecification.providers is None
-                else ", ".join([x.value for x in task_group.runSpecification.providers])
-            ),
-            worker_pool_values=(
-                UNKNOWN_STRING
-                if len(nodes) == 0
-                else (
-                    EMPTY_STRING
-                    if len(node_providers) == 0
-                    else ", ".join(node_providers)
+                else ", ".join(
+                    sorted([x.value for x in task_group.runSpecification.providers])
                 )
             ),
+            worker_pool_values=", ".join(sorted(list(worker_pool_providers))),
             match=match_type,
-            match_count=matching_node_counter if len(runspec_providers) > 0 else None,
-            total_nodes=len(nodes) if len(runspec_providers) > 0 else None,
         )
 
     def _match_regions(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         runspec_regions = (
             set()
             if task_group.runSpecification.regions is None
             else set(task_group.runSpecification.regions)
         )
-        nodes = self._get_all_nodes_in_worker_pool(worker_pool)
-        node_regions = {
-            node.details.region for node in nodes if node.details.region != ""
-        }
+        worker_pool_regions = self._get_regions(worker_pool)
 
-        # Calculate match
-        matching_node_counter = 0
-        if len(runspec_regions) == 0:
+        # Calculate match: the regions in the worker pool must be
+        # a subset of those in the run specification
+        if len(runspec_regions) == 0 or worker_pool_regions <= runspec_regions:
             match_type = MatchType.YES
-        elif len(nodes) == 0:
-            match_type = MatchType.MAYBE
         else:
-            for node in nodes:
-                if node.details.region in runspec_regions:
-                    matching_node_counter += 1
-            if matching_node_counter == 0:
-                match_type = MatchType.NO
-            elif matching_node_counter < len(nodes):
-                match_type = MatchType.PARTIAL
-            else:
-                match_type = MatchType.YES
+            match_type = MatchType.NO
 
         return PropertyMatch(
             property_name="Region(s)",
             task_group_values=(
                 EMPTY_STRING
                 if task_group.runSpecification.regions is None
-                else ", ".join(task_group.runSpecification.regions)
+                else ", ".join(sorted(task_group.runSpecification.regions))
             ),
             worker_pool_values=(
-                EMPTY_STRING
-                if len(nodes) == 0
-                else ", ".join(node_regions) if len(node_regions) > 0 else NONE_STRING
+                ", ".join(sorted(list(worker_pool_regions)))
+                if len(worker_pool_regions) > 0
+                else NONE_STRING
             ),
             match=match_type,
-            match_count=matching_node_counter if len(runspec_regions) > 0 else None,
-            total_nodes=len(nodes) if len(runspec_regions) > 0 else None,
         )
 
     @staticmethod
     def _match_namespaces(
-        task_group: TaskGroup, worker_pool: WorkerPool
+        task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
         return PropertyMatch(
             property_name="Namespace(s)",
@@ -471,29 +461,28 @@ class WorkerPools:
         )
 
     def _match_ram(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
 
         nodes = self._get_all_nodes_in_worker_pool(worker_pool)
         nodes_ram = {node.details.ram for node in nodes}
 
         # Calculate match
-        matching_node_counter = 0
         if task_group.runSpecification.ram is None:
             match_type = MatchType.YES
         elif len(nodes) == 0:
             match_type = MatchType.MAYBE
         else:
             for node in nodes:
-                if self._check_in_range(
+                if not self._check_in_range(
                     node.details.ram, task_group.runSpecification.ram
                 ):
-                    matching_node_counter += 1
-            if matching_node_counter == 0:
-                match_type = MatchType.NO
-            elif matching_node_counter < len(nodes):
-                match_type = MatchType.PARTIAL
+                    # If ANY nodes fail to match, the worker
+                    # pool is not considered a match
+                    match_type = MatchType.NO
+                    break
             else:
+                # All current nodes match
                 match_type = MatchType.YES
 
         return PropertyMatch(
@@ -509,38 +498,31 @@ class WorkerPools:
                 else ", ".join([str(node_ram) for node_ram in nodes_ram])
             ),
             match=match_type,
-            match_count=(
-                None
-                if task_group.runSpecification.ram is None
-                else matching_node_counter
-            ),
-            total_nodes=None if task_group.runSpecification.ram is None else len(nodes),
         )
 
     def _match_vcpus(
-        self, task_group: TaskGroup, worker_pool: WorkerPool
+        self, task_group: TaskGroup, worker_pool: ProvisionedWorkerPool
     ) -> PropertyMatch:
 
         nodes = self._get_all_nodes_in_worker_pool(worker_pool)
         nodes_vcpus = {node.details.vcpus for node in nodes}
 
         # Calculate match
-        matching_node_counter = 0
         if task_group.runSpecification.vcpus is None:
             match_type = MatchType.YES
         elif len(nodes) == 0:
             match_type = MatchType.MAYBE
         else:
             for node in nodes:
-                if self._check_in_range(
+                if not self._check_in_range(
                     node.details.vcpus, task_group.runSpecification.vcpus
                 ):
-                    matching_node_counter += 1
-            if matching_node_counter == 0:
-                match_type = MatchType.NO
-            elif matching_node_counter < len(nodes):
-                match_type = MatchType.PARTIAL
+                    # If ANY nodes fail to match, the worker
+                    # pool is not considered a match
+                    match_type = MatchType.NO
+                    break
             else:
+                # All current nodes match
                 match_type = MatchType.YES
 
         return PropertyMatch(
@@ -556,14 +538,6 @@ class WorkerPools:
                 else ", ".join([str(node_vcpus) for node_vcpus in nodes_vcpus])
             ),
             match=match_type,
-            match_count=(
-                None
-                if task_group.runSpecification.vcpus is None
-                else matching_node_counter
-            ),
-            total_nodes=(
-                None if task_group.runSpecification.vcpus is None else len(nodes)
-            ),
         )
 
     @staticmethod
@@ -636,9 +610,9 @@ def _get_work_requirement_by_id(work_requirement_id) -> WorkRequirement:
             )
 
 
-def _get_worker_pool_by_id(worker_pool_id) -> WorkerPool:
+def _get_provisioned_worker_pool_by_id(worker_pool_id) -> ProvisionedWorkerPool:
     try:
-        return get_worker_pool_by_id(CLIENT, worker_pool_id)
+        worker_pool = get_worker_pool_by_id(CLIENT, worker_pool_id)
     except Exception as e:
         if "404" in str(e):
             raise Exception(f"Work Pool ID '{worker_pool_id}' not found")
@@ -647,6 +621,14 @@ def _get_worker_pool_by_id(worker_pool_id) -> WorkerPool:
                 f"Unable to obtain Worker Pool details for '{worker_pool_id}': {e}"
             )
 
+    if isinstance(worker_pool, ProvisionedWorkerPool):
+        return worker_pool
+    else:
+        raise Exception(
+            f"Worker Pool ID '{worker_pool_id}' is not a Provisioned Worker Pool; "
+            "Configured Worker Pools are not supported by 'yd-compare'"
+        )
+
 
 def _compare_task_group(task_group: TaskGroup, worker_pools: WorkerPools):
     """
@@ -700,13 +682,13 @@ def _compare_task_group(task_group: TaskGroup, worker_pools: WorkerPools):
 def main():
 
     # Worker pools
-    wp_list: List[WorkerPool] = []
+    wp_list: List[ProvisionedWorkerPool] = []
     for wp_id in ARGS_PARSER.worker_pool_ids:
         if get_ydid_type(wp_id) != YDIDType.WORKER_POOL:
             raise Exception(
                 f"Not a YellowDog Worker Pool ID: '{ARGS_PARSER.wr_or_tg_id}'"
             )
-        wp_list.append(_get_worker_pool_by_id(wp_id))
+        wp_list.append(_get_provisioned_worker_pool_by_id(wp_id))
     worker_pools = WorkerPools(wp_list)
 
     # Task group
@@ -723,8 +705,6 @@ def main():
             f"({work_requirement.id})",
             override_quiet=True,
         )
-        if ARGS_PARSER.running_nodes_only:
-            print_log("Comparing RUNNING nodes in the worker pool(s) only")
         for task_group in work_requirement.taskGroups:
             _compare_task_group(task_group, worker_pools)