viam-sdk 0.3.0__py3-none-linux_armv6l.whl → 0.66.0__py3-none-linux_armv6l.whl

viam/media/video.py

@@ -1,107 +1,231 @@
 from array import array
-from enum import Enum
-from io import BytesIO
-from typing import List, NamedTuple, Tuple, Union
+from typing import Any, List, Optional, Tuple
 
-from PIL.Image import Image
-from typing_extensions import Self
+from typing_extensions import ClassVar, Self
 
 from viam.errors import NotSupportedError
 
-from .viam_rgba_plugin import RGBA_FORMAT_LABEL
+from .viam_rgba import RGBA_HEADER_LENGTH, RGBA_MAGIC_NUMBER
 
-LAZY_SUFFIX = "+lazy"
 
-# Formats that are supported by PIL
-LIBRARY_SUPPORTED_FORMATS = ["JPEG", "PNG", RGBA_FORMAT_LABEL]
+class _FrozenClassAttributesMeta(type):
+    """
+    A metaclass that prevents the reassignment of existing class attributes.
+    """
 
+    def __setattr__(cls, name: str, value: Any):
+        # Check if the attribute `name` already exists on the class
+        if name in cls.__dict__:
+            # If it exists, raise an error to prevent overwriting
+            raise AttributeError(f"Cannot reassign constant '{name}'")
+        # If it's a new attribute, allow it to be set
+        super().__setattr__(name, value)
 
-class RawImage(NamedTuple):
-    """A raw bytes representation of an image.
 
-    A RawImage should be returned instead of a PIL Image instance under one of
-    the following conditions
+class CameraMimeType(str, metaclass=_FrozenClassAttributesMeta):
+    """
+    The compatible mime-types for cameras and vision services.
 
-    1) The requested mime type has the LAZY_SUFFIX string appended to it
-    2) The requested mime type is not supported for decoding/encoding by Viam's
-    Python SDK
+    You can use the `CameraMimeType.CUSTOM(...)` method to use an unlisted mime-type.
     """
 
-    data: bytes
-    """The raw data of the image"""
+    VIAM_RGBA: ClassVar[Self]
+    VIAM_RAW_DEPTH: ClassVar[Self]
+    JPEG: ClassVar[Self]
+    PNG: ClassVar[Self]
+    PCD: ClassVar[Self]
 
-    mime_type: str
-    """The mimetype of the image"""
+    @property
+    def name(self) -> str:
+        for key, value in self.__class__.__dict__.items():
+            if value == self:
+                return key
+        return "CUSTOM"
 
-    def close(self):
-        """Close the image and release resources. For RawImage, this is a noop."""
-        return
+    @property
+    def value(self) -> str:
+        return self
 
-    def bytes_to_depth_array(self) -> List[List[int]]:
-        """Decode the data of an image that has the custom depth MIME type ``image/vnd.viam.dep`` into
-        a standard representation.
+    @classmethod
+    def CUSTOM(cls, mime_type: str) -> Self:
+        """
+        Create a custom mime type.
 
-        Raises:
-            NotSupportedError: Raised if given an image that is not of MIME type `image/vnd.viam.dep`.
+        Args:
+            mime_type (str): The mimetype as a string
+        """
+        return cls.from_string(mime_type)
+
+    @classmethod
+    def from_string(cls, value: str) -> Self:
+        """Return the mimetype from a string.
+
+        Args:
+            value (str): The mimetype as a string
 
         Returns:
-            List[List[int]]: The standard representation of the image.
+            Self: The mimetype
         """
-        if self.mime_type != "image/vnd.viam.dep":
-            raise NotSupportedError("Type must be `image/vnd.viam.dep` to use bytes_to_depth_array()")
+        value_mime = value[:-5] if value.endswith("+lazy") else value  # ViamImage lazy encodes by default
+        return cls(value_mime)
 
-        width = int.from_bytes(self.data[8:16], "big")
-        height = int.from_bytes(self.data[16:24], "big")
-        depth_arr = array("H", self.data[24:])
-        depth_arr.byteswap()
 
-        depth_arr_2d = [[depth_arr[row * width + col] for col in range(width)] for row in range(height)]
-        return depth_arr_2d
+CameraMimeType.VIAM_RGBA = CameraMimeType.from_string("image/vnd.viam.rgba")
+CameraMimeType.VIAM_RAW_DEPTH = CameraMimeType.from_string("image/vnd.viam.dep")
+CameraMimeType.JPEG = CameraMimeType.from_string("image/jpeg")
+CameraMimeType.PNG = CameraMimeType.from_string("image/png")
+CameraMimeType.PCD = CameraMimeType.from_string("pointcloud/pcd")
 
 
-class CameraMimeType(str, Enum):
-    VIAM_RGBA = "image/vnd.viam.rgba"
-    JPEG = "image/jpeg"
-    PNG = "image/png"
-    PCD = "pointcloud/pcd"
-    UNSUPPORTED = "unsupported"
+class ViamImage:
+    """A native implementation of an image.
 
-    @classmethod
-    def from_lazy(cls, value: str) -> Tuple[Self, bool]:
-        is_lazy = False
-        mime_type = value
-        if value.endswith(LAZY_SUFFIX):
-            mime_type = value[: (len(value) - len(LAZY_SUFFIX))]
-            is_lazy = True
-        if not cls.is_supported(value) and not is_lazy:
-            mime_type = CameraMimeType.UNSUPPORTED
-        return (cls(mime_type), is_lazy)
+    Provides the raw data and the mime type.
+    """
+
+    _data: bytes
+    _mime_type: CameraMimeType
+    _height: Optional[int] = None
+    _width: Optional[int] = None
+
+    def __init__(self, data: bytes, mime_type: CameraMimeType) -> None:
+        self._data = data
+        self._mime_type = mime_type
+        self._width, self._height = _getDimensions(data, mime_type)
 
     @property
-    def with_lazy_suffix(self) -> str:
-        return f"{self.value}{LAZY_SUFFIX}"
+    def data(self) -> bytes:
+        """The raw bytes of the image"""
+        return self._data
 
-    def encode_image(self, image: Union[Image, RawImage]) -> bytes:
-        if isinstance(image, RawImage):
-            return image.data
+    @property
+    def mime_type(self) -> CameraMimeType:
+        """The mime type of the image"""
+        return self._mime_type
 
-        if self.name in LIBRARY_SUPPORTED_FORMATS:
-            buf = BytesIO()
-            image.save(buf, format=self.name)
-            return buf.getvalue()
-        else:
-            raise ValueError(f"Cannot encode image to {self}")
+    @property
+    def width(self) -> Optional[int]:
+        """The width of the image"""
+        return self._width
 
-    @classmethod
-    def is_supported(cls, mime_type: str) -> bool:
-        """Check if the provided mime_type is supported
+    @property
+    def height(self) -> Optional[int]:
+        """The height of the image"""
+        return self._height
 
-        Args:
-            mime_type (str): The mime_type to check
+    def bytes_to_depth_array(self) -> List[List[int]]:
+        """
+        Decode the data of an image that has the custom depth MIME type ``image/vnd.viam.dep`` into a standard representation.
+
+        Raises:
+            NotSupportedError: Raised if the image is not of MIME type `image/vnd.viam.dep`.
 
         Returns:
-            bool: Whether the mime_type is supported
+            List[List[int]]: The standard representation of the image.
         """
-        if mime_type == cls.UNSUPPORTED:
-            return False
-        return mime_type in set(item.value for item in cls)
+        if self.mime_type != CameraMimeType.VIAM_RAW_DEPTH:
+            raise NotSupportedError("Type must be `image/vnd.viam.dep` to use bytes_to_depth_array()")
+
+        self._width = int.from_bytes(self.data[8:16], "big")
+        self._height = int.from_bytes(self.data[16:24], "big")
+        depth_arr = array("H", self.data[24:])
+        depth_arr.byteswap()
+
+        depth_arr_2d = [[depth_arr[row * self._width + col] for col in range(self._width)] for row in range(self._height)]
+        return depth_arr_2d
+
+
+class NamedImage(ViamImage):
+    """An implementation of ViamImage that contains a name attribute."""
+
+    name: str
+    """The name of the image
+    """
+
+    def __init__(self, name: str, data: bytes, mime_type: CameraMimeType) -> None:
+        self.name = name
+        super().__init__(data, mime_type)
+
+
+def _getDimensions(image: bytes, mime_type: CameraMimeType) -> Tuple[Optional[int], Optional[int]]:
+    try:
+        if mime_type == CameraMimeType.JPEG:
+            return _getDimensionsFromJPEG(image)
+        if mime_type == CameraMimeType.PNG:
+            return _getDimensionsFromPNG(image)
+        if mime_type == CameraMimeType.VIAM_RGBA:
+            return _getDimensionsFromRGBA(image)
+    except ValueError:
+        return (None, None)
+    return (None, None)
+
+
+def _getDimensionsFromJPEG(image: bytes) -> Tuple[int, int]:
+    # JPEG Specification: https://www.w3.org/Graphics/JPEG/itu-t81.pdf
+    # Specification for markers: Table B.1
+
+    offset = 0
+    while offset < len(image):
+        while image[offset] == 0xFF:
+            # Skip all 0xFF bytes
+            offset += 1
+
+        marker = image[offset]
+        offset += 1
+        if marker == 0x01:
+            # Temporary/private use marker
+            offset += 1
+            continue
+        if marker in range(0xD0, 0xD7):
+            # Restart (RST) marker
+            offset += 1
+            continue
+        if marker == 0xD8:
+            # Start of image (SOI) marker
+            offset += 1
+            continue
+        if marker == 0xD9:
+            # End of image (EOI) marker
+            break
+
+        length = int.from_bytes(image[offset : offset + 1], byteorder="big")  # length of section
+        if marker == 0xC0 or marker == 0xC2:
+            height = int.from_bytes(image[offset + 3 : offset + 5], byteorder="big")
+            width = int.from_bytes(image[offset + 5 : offset + 7], byteorder="big")
+            return (width, height)
+
+        offset += length
+
+    raise ValueError("Invalid JPEG: Could not extract dimensions")
+
+
+def _getDimensionsFromPNG(image: bytes) -> Tuple[int, int]:
+    # PNG Specification: https://www.w3.org/TR/png/
+
+    # PNG will always start with this signature
+    signature = image[:8]
+    if signature != [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]:
+        ValueError("Invalid PNG: Invalid signature")
+
+    header = image[12:24]
+    chunk_type = header[:4].decode()
+    if chunk_type != "IHDR":
+        ValueError("Invalid PNG: Invalid headers")
+
+    width = int.from_bytes(header[4:8], byteorder="big")
+    height = int.from_bytes(header[8:], byteorder="big")
+    return (width, height)
+
+
+def _getDimensionsFromRGBA(image: bytes) -> Tuple[int, int]:
+    # Viam RGBA header comes in 3 4-byte chunks:
+    # * Magic Number/Signature
+    # * Width
+    # * Height
+    header = image[:RGBA_HEADER_LENGTH]
+    if header[:4] != RGBA_MAGIC_NUMBER:
+        raise ValueError("Invalid Viam RGBA: Invalid headers")
+
+    width = int.from_bytes(header[4:8], byteorder="big")
+    height = int.from_bytes(header[8:], byteorder="big")
+    return (width, height)

viam/module/module.py

@@ -1,12 +1,20 @@
+import argparse
+import io
+import logging as pylogging
+import os
+import sys
+from collections.abc import Iterable
 from inspect import iscoroutinefunction
 from threading import Lock
 from typing import List, Mapping, Optional, Sequence, Tuple
 
+from grpclib.metadata import Deadline
 from grpclib.utils import _service_name
+from typing_extensions import Self
 
 from viam import logging
-from viam.components.component_base import ComponentBase
 from viam.errors import ResourceNotFoundError, ValidationError
+from viam.logging import update_log_level
 from viam.proto.app.robot import ComponentConfig
 from viam.proto.module import (
     AddResourceRequest,
@@ -22,15 +30,50 @@ from viam.proto.module import (
 from viam.proto.robot import ResourceRPCSubtype
 from viam.resource.base import ResourceBase
 from viam.resource.registry import Registry
-from viam.resource.types import Model, ResourceName, Subtype, resource_name_from_string
+from viam.resource.types import API, RESOURCE_TYPE_COMPONENT, RESOURCE_TYPE_SERVICE, Model, ResourceName, resource_name_from_string
 from viam.robot.client import RobotClient
-from viam.rpc.dial import DialOptions
+from viam.rpc.dial import DialOptions, _host_port_from_url
 from viam.rpc.server import Server
 
+# These imports are required to register built-in resources with the registry
+from ..components.arm import Arm  # noqa: F401
+from ..components.base import Base  # noqa: F401
+from ..components.board import Board  # noqa: F401
+from ..components.button import Button  # noqa: F401
+from ..components.camera import Camera  # noqa: F401
+from ..components.encoder import Encoder  # noqa: F401
+from ..components.gantry import Gantry  # noqa: F401
+from ..components.generic import Generic as GenericComponent  # noqa: F401
+from ..components.gripper import Gripper  # noqa: F401
+from ..components.input import Controller  # noqa: F401
+from ..components.motor import Motor  # noqa: F401
+from ..components.movement_sensor import MovementSensor  # noqa: F401
+from ..components.pose_tracker import PoseTracker  # noqa: F401
+from ..components.power_sensor import PowerSensor  # noqa: F401
+from ..components.sensor import Sensor  # noqa: F401
+from ..components.servo import Servo  # noqa: F401
+from ..components.switch import Switch  # noqa: F401
+from ..services.discovery import Discovery  # noqa: F401
+from ..services.generic import Generic as GenericService  # noqa: F401
+from ..services.motion import Motion  # noqa: F401
+from ..services.navigation import Navigation  # noqa: F401
+from ..services.slam import SLAM  # noqa: F401
+from ..services.vision import Vision  # noqa: F401
 from .service import ModuleRPCService
 from .types import Reconfigurable, Stoppable
 
-LOGGER = logging.getLogger(__name__)
+NO_MODULE_PARENT = os.environ.get("VIAM_NO_MODULE_PARENT", "").lower() == "true"
+
+
+def _parse_module_args() -> argparse.Namespace:
+    """
+    Parse command-line args. Used by the various `Module` entrypoints.
+    """
+    p = argparse.ArgumentParser(description="Start this viam python module")
+    p.add_argument("socket_path", help="path where this module will serve a unix socket")
+    p.add_argument("--log-level", type=lambda name: pylogging._nameToLevel[name.upper()], default=logging.INFO)
+    p.add_argument("--tcp-mode", action="store_true")
+    return p.parse_known_args()[0]
 
 
 class Module:
@@ -39,17 +82,83 @@ class Module:
     _ready: bool
     _log_level: int
     _lock: Lock
+    _tcp_mode: bool
     parent: Optional[RobotClient] = None
     server: Server
+    logger: pylogging.Logger
+
+    @classmethod
+    def from_args(cls) -> Self:
+        """Create a new Module with the args provided in the command line. The first argument after the command must be
+        the socket path. If the second argument after the command is "--log-level=debug", the Module's logger will be
+        DEBUG level. Otherwise, it will be INFO level. See LogLevel documentation in the RDK for more information on how
+        to start modules with a "log-level" commandline argument.
+
+        Raises:
+            Exception: If there is no socket path provided in the command line argument
+
+        Returns:
+            Module: a new Module instance
+        """
+        args = _parse_module_args()
+        return cls(args.socket_path, log_level=args.log_level, tcp_mode=args.tcp_mode)
+
+    @classmethod
+    async def run_with_models(cls, *models: ResourceBase):
+        """
+        Module entrypoint that takes a list of ResourceBase implementations.
+        In most cases you'll want to use run_from_registry instead (see below).
+        """
+        module = cls.from_args()
+        for model in models:
+            if not hasattr(model, "MODEL"):
+                raise TypeError(f"missing MODEL field on {model}. Resource implementations must define MODEL")
+            module.add_model_from_registry(model.API, model.MODEL)  # pyright: ignore [reportAttributeAccessIssue]
+        await module.start()
+
+    @classmethod
+    async def run_from_registry(cls):
+        """
+        Module entrypoint that automatically includes all the resources you've created in your program.
+
+        Example:
+
+        if __name__ == '__main__':
+            asyncio.run(Module.run_from_registry())
 
-    def __init__(self, address: str, *, log_level: int = logging.DEBUG) -> None:
+        Full example at examples/easy_resource/main.py.
+        """
+        module = cls.from_args()
+        for key in Registry.REGISTERED_RESOURCE_CREATORS().keys():
+            module.add_model_from_registry(*key.split("/"))  # pyright: ignore [reportArgumentType]
+        await module.start()
+
+    def __init__(self, address: str, *, log_level: int = logging.INFO, tcp_mode: bool = False) -> None:
+        # When a module is launched by viam-server, its stdout is not connected to a tty.  In
+        # response, python disables line buffering, which prevents `print` statements from being
+        # immediately flushed to viam-server. This behavior can be confusing, interfere with
+        # debugging, and is non-standard when compared to other languages.  Here, stdout and stderr
+        # are reconfigured to immediately flush.
+        if isinstance(sys.stdout, io.TextIOWrapper):
+            sys.stdout.reconfigure(line_buffering=True)
+        if isinstance(sys.stderr, io.TextIOWrapper):
+            sys.stderr.reconfigure(line_buffering=True)
         self._address = address
+        self._tcp_mode = tcp_mode
         self.server = Server(resources=[], module_service=ModuleRPCService(self))
         self._log_level = log_level
+
+        module_name = os.environ.get("VIAM_MODULE_NAME")
+        # this can happen if the user is running an old version of viam-server that doesn't set `VIAM_MODULE_NAME`
+        if module_name is None:
+            module_name = __name__
+        self.logger = logging.getLogger(module_name)
         self._ready = True
         self._lock = Lock()
 
     async def _connect_to_parent(self):
+        if NO_MODULE_PARENT:
+            return
         if self.parent is None:
             if self._parent_address is None:
                 raise ValueError("Parent address not found")
@@ -60,40 +169,50 @@ class Module:
                     log_level=self._log_level,
                 ),
             )
+            self.logger.debug("Starting module logging")
+            logging.setParent(self.parent)
 
-    async def _get_component(self, name: ResourceName) -> ComponentBase:
+    async def _get_resource(self, name: ResourceName) -> ResourceBase:
         await self._connect_to_parent()
         assert self.parent is not None
         await self.parent.refresh()
-        return self.parent.get_component(name)
+        if name.type == RESOURCE_TYPE_COMPONENT:
+            return self.parent.get_component(name)
+        elif name.type == RESOURCE_TYPE_SERVICE:
+            return self.parent.get_service(name)
+        raise ValueError("Dependency does not describe a component nor a service")
 
-    async def _get_dependencies(self, dependencies: Sequence[str]) -> Mapping[ResourceName, ComponentBase]:
-        deps: Mapping[ResourceName, ComponentBase] = {}
+    async def _get_dependencies(self, dependencies: Sequence[str]) -> Mapping[ResourceName, ResourceBase]:
+        deps: Mapping[ResourceName, ResourceBase] = {}
         for dep in dependencies:
             rn = resource_name_from_string(dep)
-            component = await self._get_component(rn)
-            deps[rn] = component
+            deps[rn] = await self._get_resource(rn)
         return deps
 
     async def start(self):
         """Start the module service and gRPC server"""
         try:
-            await self.server.serve(log_level=self._log_level, path=self._address)
+            if self._tcp_mode:
+                host, port = _host_port_from_url(self._address)
+                await self.server.serve(log_level=self._log_level, host=host, port=port)
+            else:
+                await self.server.serve(log_level=self._log_level, path=self._address)
         finally:
             await self.stop()
 
     async def stop(self):
         """Stop the module service and gRPC server"""
-        LOGGER.debug("Shutting down module")
+        self.logger.debug("Shutting down module")
         try:
+            logging.shutdown()
             if self.parent is not None:
                 await self.parent.close()
         except Exception as e:
-            LOGGER.error("Encountered error while shutting down module", exc_info=e)
+            self.logger.error("Encountered error while shutting down module", exc_info=e)
 
     def set_ready(self, ready: bool):
         """Set the module's ready state. The module automatically sets to READY on load. Setting to False can be useful
-        in instances where the module is not instantly ready (e.g. waiting on hardware)
+        in instances where the module is not instantly ready (for example waiting on hardware)
 
         Args:
             ready (bool): Whether the module is ready
@@ -101,21 +220,24 @@ class Module:
         with self._lock:
             self._ready = ready
 
-    async def add_resource(self, request: AddResourceRequest):
+    async def add_resource(self, request: AddResourceRequest, *, deadline: Optional[Deadline] = None):
         dependencies = await self._get_dependencies(request.dependencies)
         config: ComponentConfig = request.config
-        subtype = Subtype.from_string(config.api)
+        api = API.from_string(config.api)
         model = Model.from_string(config.model, ignore_errors=True)
-        creator = Registry.lookup_resource_creator(subtype, model)
+        creator = Registry.lookup_resource_creator(api, model)
         resource = creator(config, dependencies)
+        if deadline is not None and deadline.time_remaining() <= 0:
+            raise TimeoutError("Deadline expired")
+        update_log_level(resource.logger, config.log_configuration.level.upper())
         self.server.register(resource)
 
     async def reconfigure_resource(self, request: ReconfigureResourceRequest):
         dependencies = await self._get_dependencies(request.dependencies)
         config: ComponentConfig = request.config
-        subtype = Subtype.from_string(config.api)
+        api = API.from_string(config.api)
         name = config.name
-        rn = ResourceName(namespace=subtype.namespace, type=subtype.resource_type, subtype=subtype.resource_subtype, name=name)
+        rn = ResourceName(namespace=api.namespace, type=api.resource_type, subtype=api.resource_subtype, name=name)
         resource = self.server.get_resource(ResourceBase, rn)
         if isinstance(resource, Reconfigurable):
             resource.reconfigure(config, dependencies)
@@ -126,44 +248,48 @@ class Module:
                 else:
                     resource.stop()
             add_request = AddResourceRequest(config=request.config, dependencies=request.dependencies)
-            self.server.remove_resource(rn)
+            await self.server.remove_resource(rn)
             await self.add_resource(add_request)
 
     async def remove_resource(self, request: RemoveResourceRequest):
         rn = resource_name_from_string(request.name)
         resource = self.server.get_resource(ResourceBase, rn)
         if isinstance(resource, Stoppable):
-            if iscoroutinefunction(resource.stop):
-                await resource.stop()
-            else:
-                resource.stop()
-        self.server.remove_resource(rn)
+            try:
+                if iscoroutinefunction(resource.stop):
+                    await resource.stop()
+                else:
+                    resource.stop()
+            except Exception as e:
+                self.logger.warning(f"Could not remove resource named {resource.name}", exc_info=e)
+        await self.server.remove_resource(rn)
 
     async def ready(self, request: ReadyRequest) -> ReadyResponse:
         self._parent_address = request.parent_address
+        await self._connect_to_parent()
 
-        svcname_to_models: Mapping[Tuple[str, Subtype], List[Model]] = {}
-        for subtype_model_str in Registry.REGISTERED_RESOURCE_CREATORS().keys():
-            subtype_str, model_str = subtype_model_str.split("/")
-            subtype = Subtype.from_string(subtype_str)
+        svcname_to_models: Mapping[Tuple[str, API], List[Model]] = {}
+        for api_model_str in Registry.REGISTERED_RESOURCE_CREATORS().keys():
+            api_str, model_str = api_model_str.split("/")
+            api = API.from_string(api_str)
             model = Model.from_string(model_str)
 
-            registration = Registry.lookup_subtype(subtype)
+            registration = Registry.lookup_api(api)
             service = registration.rpc_service(self.server)
             service_name = _service_name(service)
 
-            models = svcname_to_models.get((service_name, subtype), [])
+            models = svcname_to_models.get((service_name, api), [])
             models.append(model)
-            svcname_to_models[(service_name, subtype)] = models
+            svcname_to_models[(service_name, api)] = models
 
         handlers: List[HandlerDefinition] = []
         for key, value in svcname_to_models.items():
-            svc_name, subtype = key
+            svc_name, api = key
             rpc_subtype = ResourceRPCSubtype(
                 subtype=ResourceName(
-                    namespace=subtype.namespace,
-                    type=subtype.resource_type,
-                    subtype=subtype.resource_subtype,
+                    namespace=api.namespace,
+                    type=api.resource_type,
+                    subtype=api.resource_subtype,
                     name="",
                 ),
                 proto_service=svc_name,
@@ -173,22 +299,43 @@ class Module:
 
         return ReadyResponse(ready=self._ready, handlermap=HandlerMap(handlers=handlers))
 
-    def add_model_from_registry(self, subtype: Subtype, model: Model):
+    def add_model_from_registry(self, api: API, model: Model):
         """Add a pre-registered model to this Module"""
 
         # All we need to do is double check that the model has already been registered
         try:
-            Registry.lookup_resource_creator(subtype, model)
+            Registry.lookup_resource_creator(api, model)
         except ResourceNotFoundError:
-            raise ValueError(f"Cannot add model because it has not been registered. Subtype: {subtype}. Model: {model}")
+            raise ValueError(f"Cannot add model because it has not been registered. API: {api}. Model: {model}")
 
     async def validate_config(self, request: ValidateConfigRequest) -> ValidateConfigResponse:
         config: ComponentConfig = request.config
-        subtype = Subtype.from_string(config.api)
+        api = API.from_string(config.api)
         model = Model.from_string(config.model)
-        validator = Registry.lookup_validator(subtype, model)
+        validator = Registry.lookup_validator(api, model)
         try:
-            dependencies = validator(config)
-            return ValidateConfigResponse(dependencies=dependencies)
+            # backwards compatibility. Support both ([], []) or [] with deprecation warning.
+            # If user's validate returns [str], it will be treated as required dependencies only.
+            # Incorect formats, e.g. int, will raise ValidationError.
+            _validator_return_test = validator(config)
+            if not (isinstance(_validator_return_test, tuple) and len(_validator_return_test) == 2):
+                msg = f"Your validate function {validator.__name__} did not return \
+                        type tuple[Sequence[str], Sequence[str]]. Got {_validator_return_test}."
+                self.logger.warning(msg)
+                if (isinstance(_validator_return_test, Iterable) and not isinstance(_validator_return_test, str)) and all(
+                    isinstance(e, str)
+                    for e in _validator_return_test  # type: ignore
+                ):
+                    self.logger.warning(
+                        f"Detected deprecated validate function signature. \
+                                        Treating all dependencies {_validator_return_test} as required dependencies. \
+                                        Please update to new signature Tuple[Sequence[str], Sequence[str]] soon."
+                    )
+                    return ValidateConfigResponse(dependencies=_validator_return_test)
+                else:
+                    raise ValidationError(msg)
+
+            dependencies, optional_dependencies = _validator_return_test
+            return ValidateConfigResponse(dependencies=dependencies, optional_dependencies=optional_dependencies)
         except Exception as e:
             raise ValidationError(f"{type(Exception)}: {e}").grpc_error