gpustack-runtime 0.1.40.post1__py3-none-any.whl → 0.1.41__py3-none-any.whl

gpustack_runtime/deployer/k8s/types/kubelet/deviceplugin/v1beta1/api_pb2_grpc.py

@@ -0,0 +1,358 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from gpustack_runtime.deployer.k8s.types.kubelet.deviceplugin.v1beta1 import api_pb2 as gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2
+
+
+class RegistrationStub(object):
+    """Registration is the service advertised by the Kubelet
+    Only when Kubelet answers with a success code to a Register Request
+    may Device Plugins start their service
+    Registration may fail when device plugin version is not supported by
+    Kubelet or the registered resourceName is already taken by another
+    active device plugin. Device plugin is expected to terminate upon registration failure
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Register = channel.unary_unary(
+                '/v1beta1.Registration/Register',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.RegisterRequest.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.FromString,
+                _registered_method=True)
+
+
+class RegistrationServicer(object):
+    """Registration is the service advertised by the Kubelet
+    Only when Kubelet answers with a success code to a Register Request
+    may Device Plugins start their service
+    Registration may fail when device plugin version is not supported by
+    Kubelet or the registered resourceName is already taken by another
+    active device plugin. Device plugin is expected to terminate upon registration failure
+    """
+
+    def Register(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_RegistrationServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Register': grpc.unary_unary_rpc_method_handler(
+                    servicer.Register,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.RegisterRequest.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'v1beta1.Registration', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('v1beta1.Registration', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class Registration(object):
+    """Registration is the service advertised by the Kubelet
+    Only when Kubelet answers with a success code to a Register Request
+    may Device Plugins start their service
+    Registration may fail when device plugin version is not supported by
+    Kubelet or the registered resourceName is already taken by another
+    active device plugin. Device plugin is expected to terminate upon registration failure
+    """
+
+    @staticmethod
+    def Register(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/v1beta1.Registration/Register',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.RegisterRequest.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class DevicePluginStub(object):
+    """DevicePlugin is the service advertised by Device Plugins
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.GetDevicePluginOptions = channel.unary_unary(
+                '/v1beta1.DevicePlugin/GetDevicePluginOptions',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.DevicePluginOptions.FromString,
+                _registered_method=True)
+        self.ListAndWatch = channel.unary_stream(
+                '/v1beta1.DevicePlugin/ListAndWatch',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.ListAndWatchResponse.FromString,
+                _registered_method=True)
+        self.GetPreferredAllocation = channel.unary_unary(
+                '/v1beta1.DevicePlugin/GetPreferredAllocation',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationRequest.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationResponse.FromString,
+                _registered_method=True)
+        self.Allocate = channel.unary_unary(
+                '/v1beta1.DevicePlugin/Allocate',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateRequest.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateResponse.FromString,
+                _registered_method=True)
+        self.PreStartContainer = channel.unary_unary(
+                '/v1beta1.DevicePlugin/PreStartContainer',
+                request_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerRequest.SerializeToString,
+                response_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerResponse.FromString,
+                _registered_method=True)
+
+
+class DevicePluginServicer(object):
+    """DevicePlugin is the service advertised by Device Plugins
+    """
+
+    def GetDevicePluginOptions(self, request, context):
+        """GetDevicePluginOptions returns options to be communicated with Device
+        Manager
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListAndWatch(self, request, context):
+        """ListAndWatch returns a stream of List of Devices
+        Whenever a Device state change or a Device disappears, ListAndWatch
+        returns the new list
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetPreferredAllocation(self, request, context):
+        """GetPreferredAllocation returns a preferred set of devices to allocate
+        from a list of available ones. The resulting preferred allocation is not
+        guaranteed to be the allocation ultimately performed by the
+        devicemanager. It is only designed to help the devicemanager make a more
+        informed allocation decision when possible.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Allocate(self, request, context):
+        """Allocate is called during container creation so that the Device
+        Plugin can run device specific operations and instruct Kubelet
+        of the steps to make the Device available in the container
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def PreStartContainer(self, request, context):
+        """PreStartContainer is called, if indicated by Device Plugin during registeration phase,
+        before each container start. Device plugin can run device specific operations
+        such as resetting the device before making devices available to the container
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_DevicePluginServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'GetDevicePluginOptions': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetDevicePluginOptions,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.DevicePluginOptions.SerializeToString,
+            ),
+            'ListAndWatch': grpc.unary_stream_rpc_method_handler(
+                    servicer.ListAndWatch,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.ListAndWatchResponse.SerializeToString,
+            ),
+            'GetPreferredAllocation': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetPreferredAllocation,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationRequest.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationResponse.SerializeToString,
+            ),
+            'Allocate': grpc.unary_unary_rpc_method_handler(
+                    servicer.Allocate,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateRequest.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateResponse.SerializeToString,
+            ),
+            'PreStartContainer': grpc.unary_unary_rpc_method_handler(
+                    servicer.PreStartContainer,
+                    request_deserializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerRequest.FromString,
+                    response_serializer=gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'v1beta1.DevicePlugin', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('v1beta1.DevicePlugin', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class DevicePlugin(object):
+    """DevicePlugin is the service advertised by Device Plugins
+    """
+
+    @staticmethod
+    def GetDevicePluginOptions(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/v1beta1.DevicePlugin/GetDevicePluginOptions',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.DevicePluginOptions.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListAndWatch(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/v1beta1.DevicePlugin/ListAndWatch',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.Empty.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.ListAndWatchResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def GetPreferredAllocation(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/v1beta1.DevicePlugin/GetPreferredAllocation',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationRequest.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreferredAllocationResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Allocate(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/v1beta1.DevicePlugin/Allocate',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateRequest.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.AllocateResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def PreStartContainer(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/v1beta1.DevicePlugin/PreStartContainer',
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerRequest.SerializeToString,
+            gpustack__runtime_dot_deployer_dot_k8s_dot_types_dot_kubelet_dot_deviceplugin_dot_v1beta1_dot_api__pb2.PreStartContainerResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

gpustack_runtime/deployer/k8s/types/kubelet/deviceplugin/v1beta1/constants.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+Healthy = "Healthy"
+"""
+Healthy means that the device is healthy
+"""
+
+Unhealthy = "Unhealthy"
+"""
+Unhealthy means that the device is unhealthy
+"""
+
+Version = "v1beta1"
+"""
+Version means current version of the API supported by kubelet
+"""
+
+DevicePluginPath = Path("/var/lib/kubelet/device-plugins")
+"""
+DevicePluginPath is the folder the Device Plugin is expecting sockets to be on
+Only privileged pods have access to this path
+Note: Placeholder until we find a "standard path"
+"""
+
+KubeletSocket = DevicePluginPath / "kubelet.sock"
+"""
+KubeletSocket is the path of the Kubelet registry socket
+"""
+
+KubeletPreStartContainerRPCTimeoutInSecs = 30
+"""
+KubeletPreStartContainerRPCTimeoutInSecs is the timeout duration in secs for PreStartContainer RPC
+Timeout duration in secs for PreStartContainer RPC
+"""

gpustack_runtime/deployer/kuberentes.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import contextlib
 import json
@@ -7,13 +7,14 @@ import operator
 import os
 from dataclasses import dataclass, field
 from enum import Enum
-from functools import lru_cache, reduce
+from functools import reduce
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 import kubernetes
 import kubernetes.stream.ws_client
 import urllib3.connection
+from cachetools.func import ttl_cache
 from dataclasses_json import dataclass_json
 
 from .. import envs
@@ -42,6 +43,7 @@ from .__utils__ import (
     sensitive_env_var,
     validate_rfc1123_domain_name,
 )
+from .k8s.deviceplugin import cdi_kind_to_kdp_resource
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator
@@ -302,7 +304,7 @@ class KubernetesDeployer(EndoscopicDeployer):
     """
 
     @staticmethod
-    @lru_cache
+    @ttl_cache(maxsize=1, ttl=60)
     def is_supported() -> bool:
         """
         Check if the deployer is supported in the current environment.
@@ -990,10 +992,15 @@ class KubernetesDeployer(EndoscopicDeployer):
 
             # Parameterize resources
             if c.resources:
+                kdp = (
+                    envs.GPUSTACK_RUNTIME_KUBERNETES_RESOURCE_INJECTION_POLICY.lower()
+                    == "kdp"
+                )
+
                 resources: dict[str, str] = {}
                 r_k_runtime_env = workload.resource_key_runtime_env_mapping or {}
                 r_k_backend_env = workload.resource_key_backend_env_mapping or {}
-                _, vd_env, _, vd_values = self.get_visible_devices_materials()
+                _, vd_env, vd_cdis, vd_values = self.get_visible_devices_materials()
                 for r_k, r_v in c.resources.items():
                     if r_k in ("cpu", "memory"):
                         resources[r_k] = str(r_v)
@@ -1032,6 +1039,15 @@ class KubernetesDeployer(EndoscopicDeployer):
                             # so that the container backend (e.g., NVIDIA Container Toolkit) can handle it,
                             # and mount corresponding libs if needed.
                             for re in runtime_env:
+                                # Request device via KDP.
+                                if kdp:
+                                    for v in vd_values.get(re) or []:
+                                        kdp_resource = cdi_kind_to_kdp_resource(
+                                            cdi_kind=vd_cdis[re],
+                                            device_index=v,
+                                        )
+                                        resources[kdp_resource] = "1"
+                                    continue
                                 # Request device via visible devices env.
                                 rv = ",".join(vd_values.get(re) or ["all"])
                                 container.env.append(
@@ -1046,6 +1062,23 @@ class KubernetesDeployer(EndoscopicDeployer):
                             # so that the container backend (e.g., NVIDIA Container Toolkit) can handle it,
                             # and mount corresponding libs if needed.
                             for re in runtime_env:
+                                # Request device via KDP.
+                                if kdp:
+                                    if not privileged:
+                                        for v in str(r_v).split(","):
+                                            kdp_resource = cdi_kind_to_kdp_resource(
+                                                cdi_kind=vd_cdis[re],
+                                                device_index=int(v.strip()),
+                                            )
+                                            resources[kdp_resource] = "1"
+                                    else:
+                                        for v in vd_values.get(re) or []:
+                                            kdp_resource = cdi_kind_to_kdp_resource(
+                                                cdi_kind=vd_cdis[re],
+                                                device_index=v,
+                                            )
+                                            resources[kdp_resource] = "1"
+                                    continue
                                 # Request device via visible devices env.
                                 if not privileged:
                                     rv = str(r_v)

gpustack_runtime/deployer/podman.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import contextlib
 import io
@@ -10,7 +10,7 @@ import socket
 import sys
 import tarfile
 from dataclasses import dataclass, field
-from functools import lru_cache, reduce
+from functools import reduce
 from math import ceil
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -22,6 +22,7 @@ import podman.domain.containers
 import podman.domain.images
 import podman.domain.volumes
 import podman.errors
+from cachetools.func import ttl_cache
 from dataclasses_json import dataclass_json
 from gpustack_runner import split_image
 from podman.domain.containers_create import CreateMixin
@@ -57,7 +58,7 @@ from .__utils__ import (
     safe_json,
     sensitive_env_var,
 )
-from .cdi import generate_config as cdi_generate_config
+from .cdi import dump_config as cdi_dump_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator
@@ -317,7 +318,7 @@ class PodmanDeployer(EndoscopicDeployer):
     """
 
     @staticmethod
-    @lru_cache
+    @ttl_cache(maxsize=1, ttl=60)
     def is_supported() -> bool:
         """
         Check if Podman is supported in the current environment.
@@ -998,9 +999,9 @@ class PodmanDeployer(EndoscopicDeployer):
                             privileged = create_options.get("privileged", False)
 
                             # Generate CDI config if not yet.
-                            if envs.GPUSTACK_RUNTIME_DEPLOY_CDI_SPECS_GENERATE:
+                            if envs.GPUSTACK_RUNTIME_PODMAN_CDI_SPECS_GENERATE:
                                 for re in runtime_env:
-                                    cdi_generate_config(
+                                    cdi_dump_config(
                                         manufacturer=vd_manus[re],
                                         output=envs.GPUSTACK_RUNTIME_DEPLOY_CDI_SPECS_DIRECTORY,
                                     )
@@ -1484,7 +1485,7 @@ class PodmanDeployer(EndoscopicDeployer):
     def _get(
         self,
         name: WorkloadName,
-        namespace: WorkloadNamespace | None = None,  # noqa: ARG002
+        namespace: WorkloadNamespace | None = None,
     ) -> WorkloadStatus | None:
         """
         Get the status of a Podman workload.
@@ -1605,7 +1606,7 @@ class PodmanDeployer(EndoscopicDeployer):
     @_supported
     def _list(
         self,
-        namespace: WorkloadNamespace | None = None,  # noqa: ARG002
+        namespace: WorkloadNamespace | None = None,
         labels: dict[str, str] | None = None,
     ) -> list[WorkloadStatus]:
         """

gpustack_runtime/detector/__init__.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations as __future_annotations__
 
 import logging
 
@@ -13,9 +13,8 @@ from .__types__ import (
     backend_to_manufacturer,
     manufacturer_to_backend,
     reduce_devices_distances,
-    supported_backends,
-    supported_manufacturers,
 )
+from .__utils__ import str_range_to_list
 from .amd import AMDDetector
 from .ascend import AscendDetector
 from .cambricon import CambriconDetector
@@ -62,6 +61,42 @@ def supported_list() -> list[Detector]:
     return [det for det in _DETECTORS if det.is_supported()]
 
 
+def available_manufacturers() -> list[ManufacturerEnum]:
+    """
+    Get a list of available manufacturers,
+    regardless of whether they are supported or not.
+
+    Returns:
+        A list of available manufacturers.
+
+    """
+    return list(_DETECTORS_MAP.keys())
+
+
+def supported_manufacturers() -> list[ManufacturerEnum]:
+    """
+    Get a list of supported manufacturers,
+    must be supported in the current environment.
+
+    Returns:
+        A list of supported manufacturers.
+
+    """
+    return [det.manufacturer for det in _DETECTORS if det.is_supported()]
+
+
+def available_backends() -> list[str]:
+    """
+    Get a list of available backends,
+    regardless of whether they are supported or not.
+
+    Returns:
+        A list of available backends.
+
+    """
+    return [manufacturer_to_backend(manu) for manu in _DETECTORS_MAP]
+
+
 def detect_backend(
     fast: bool = True,
     manufacturer: ManufacturerEnum = None,
@@ -186,7 +221,7 @@ def get_devices_topologies(
         devices = detect_devices(fast=fast, manufacturer=manufacturer)
         if not devices:
             return []
-        group = True and not fast
+        group = not fast
 
     # Group devices by manufacturer.
     if group:
@@ -260,6 +295,8 @@ __all__ = [
     "Devices",
     "ManufacturerEnum",
     "Topology",
+    "available_backends",
+    "available_manufacturers",
     "backend_to_manufacturer",
     "detect_backend",
     "detect_devices",
@@ -268,7 +305,7 @@ __all__ = [
     "group_devices_by_manufacturer",
     "manufacturer_to_backend",
     "reduce_devices_distances",
-    "supported_backends",
+    "str_range_to_list",
     "supported_list",
     "supported_manufacturers",
 ]