device.py

"""Contains the Device base class."""
import abc

from typing import List
from typing import TYPE_CHECKING

from mpf.core.machine import MachineController
from mpf.core.logging import LogMixin

if TYPE_CHECKING:
    from mpf.core.config_validator import ConfigDict
    from mpf.core.platform import BasePlatform


class Device(LogMixin, metaclass=abc.ABCMeta):

    """Generic parent class of for every hardware device in a pinball machine."""

    # String of the config section name
    config_section = None   # type: str

    # String name of the collection
    collection = None       # type: str

    # String of the friendly name of the device class
    class_label = None      # type: str

    # Can a config for this device be empty?
    allow_empty_configs = False

    def __init__(self, machine: MachineController, name: str) -> None:
        """Set up default attributes of every device.

        Args:
            machine: The machine controller.
            name: Name of the device in config.
        """
        super().__init__()
        self.machine = machine
        self.name = name.lower()
        self.tags = []          # type: List[str]
        self.label = None       # type: str
        self.platform = None    # type: BasePlatform
        self.config = dict()    # type: ConfigDict

    @classmethod
    def get_config_spec(cls):
        """Return config spec for this device."""
        return False

    def load_platform_section(self, platform_section: str):
        """Can be called in _initialize to load the platform section.

        Args:
            platform_section: Name of the platform section.
        """
        self.platform = self.machine.get_platform_sections(platform_section, self.config['platform'])

    @classmethod
    def prepare_config(cls, config: dict, is_mode_config: bool) -> dict:
        """Return the config prepared for validation.

        Args:
            config: Config of device
            is_mode_config: Whether this device is loaded in a mode or system-wide

        Returns: Prepared config
        """
        del is_mode_config
        return config

    def validate_and_parse_config(self, config: dict, is_mode_config: bool) -> dict:
        """Return the parsed and validated config.

        Args:
            config: Config of device
            is_mode_config: Whether this device is loaded in a mode or system-wide

        Returns: Validated config
        """
        del is_mode_config
        self.machine.config_validator.validate_config(
            self.config_section, config, self.name, "device")

        self._configure_device_logging(config)

        return config

    def _configure_device_logging(self, config):

        if config['debug']:
            config['console_log'] = 'full'
            config['file_log'] = 'full'

        self.configure_logging(self.class_label + '.' + self.name,
                               config['console_log'],
                               config['file_log'])

        self.debug_log('Platform Driver: %s', self.platform)
        self.debug_log("Configuring device with settings: '%s'", config)

    def load_config(self, config: dict):
        """Load config.

        Args:
            config: Config for device
        """
        self.config = config

        self.tags = self.config['tags']
        self.label = self.config['label']

    def __repr__(self):
        """Return string representation."""
        return '<{self.class_label}.{self.name}>'.format(self=self)

    # def enable_debugging(self):
    #     """Enable debug logging."""
    #     self.debug_log("Enabling debug logging")
    #     self.debug = True
    #     self._enable_related_device_debugging()
    #
    # def disable_debugging(self):
    #     """Disable debug logging."""
    #     self.debug_log("Disabling debug logging")
    #     self.debug = False
    #     self._disable_related_device_debugging()
    #
    # def _enable_related_device_debugging(self):
    #     pass
    #
    # def _disable_related_device_debugging(self):
    #     pass

    @classmethod
    def get_config_info(cls):
        """Return config collection and config section.

        Returns (str, str): Tuple with (collection, config_section)
        """
        return cls.collection, cls.config_section

    def _initialize(self):
        """Default initialize method."""
        pass