Service component:

# See the License for the specific language governing permissions and

# limitations under the License.

import json

import json, logging

from enum import Enum

from typing import TYPE_CHECKING, Any, Dict, Optional, Union

from common.method_wrappers.ServiceExceptions import NotFoundException

from common.proto.context_pb2 import Connection, ConnectionId, Device, DeviceId, Service, ServiceId

from common.proto.context_pb2 import Connection, ConnectionId, Device, DeviceDriverEnum, DeviceId, Service, ServiceId

from common.tools.context_queries.Connection import get_connection_by_id

from common.tools.context_queries.Device import get_device

from common.tools.context_queries.Service import get_service_by_id

from common.tools.grpc.Tools import grpc_message_list_to_json_string

from common.tools.object_factory.Device import json_device_id

from context.client.ContextClient import ContextClient

from device.client.DeviceClient import DeviceClient

from service.service.service_handler_api.Exceptions import (

    UnsatisfiedFilterException, UnsupportedFilterFieldException, UnsupportedFilterFieldValueException)

from service.service.service_handler_api.ServiceHandlerFactory import ServiceHandlerFactory, get_service_handler_class

from service.service.tools.ObjectKeys import get_connection_key, get_device_key, get_service_key

if TYPE_CHECKING:

    from service.service.service_handler_api._ServiceHandler import _ServiceHandler

LOGGER = logging.getLogger(__name__)

CacheableObject = Union[Connection, Device, Service]

class CacheableObjectType(Enum):

        self, connection : Connection, service : Service, **service_handler_settings

    ) -> '_ServiceHandler':

        connection_devices = self.get_devices_from_connection(connection, exclude_managed_by_controller=True)

        service_handler_class = get_service_handler_class(self._service_handler_factory, service, connection_devices)

        try:

            service_handler_class = get_service_handler_class(

                self._service_handler_factory, service, connection_devices)

            return service_handler_class(service, self, **service_handler_settings)

        except (UnsatisfiedFilterException, UnsupportedFilterFieldException, UnsupportedFilterFieldValueException):

            dict_connection_devices = {

                cd_data.name : (cd_uuid, cd_data.name, {

                    (device_driver, DeviceDriverEnum.Name(device_driver))

                    for device_driver in cd_data.device_drivers

                })

                for cd_uuid,cd_data in connection_devices.items()

            }

            LOGGER.exception(

                'Unable to select service handler. service={:s} connection={:s} connection_devices={:s}'.format(

                    grpc_message_list_to_json_string(service), grpc_message_list_to_json_string(connection),

                    str(dict_connection_devices)

                )

            )