Skip to content

Home Information - Your home, your data, organized.

Python
18.9 KB
Raw Blame
import dataclasses
from cachetools import TTLCache
from typing import Dict, List, Set, Sequence

from django.conf import settings
from django.db.models import prefetch_related_objects

from hi.apps.control.transient_models import ControllerData
from hi.apps.common.singleton import Singleton
from hi.apps.entity.models import Entity, EntityState
from hi.apps.location.svg_item_factory import SvgItemFactory
from hi.apps.sense.models import Sensor
from hi.apps.sense.sensor_response_manager import SensorResponseMixin
from hi.apps.sense.transient_models import SensorResponse
from hi.testing.dev_injection import DevInjectionManager
from hi.testing.dev_overrides import DevOverrideManager

from .display_data import EntityStateDisplayData
from .status_data import EntityStatusData, EntityStateStatusData


class StatusDisplayManager( Singleton, SensorResponseMixin ):

    STATUS_VALUE_OVERRIDES_SECS = 11

    def __init_singleton__( self ):
        self._status_value_overrides = TTLCache(
            maxsize = 100,
            ttl = self.STATUS_VALUE_OVERRIDES_SECS,
        )
        return
        
    def get_entity_state_status_map( self ) -> Dict[ str, dict ]:
        """Build the per-EntityState polling-update map consumed by
        the client. Keyed by the EntityState id (as a string, since
        JSON object keys are always strings). The value shape is
        defined by ``EntityStateDisplayData.to_polling_update_dict``."""

        entity_state_status_data_list = self.get_all_entity_state_status_data_list()

        status_map : Dict[ str, dict ] = {}
        for entity_state_status_data in entity_state_status_data_list:
            status_display_data = EntityStateDisplayData( entity_state_status_data )
            state_id_key = str( status_display_data.entity_state.id )
            status_map[ state_id_key ] = status_display_data.to_polling_update_dict()
            if settings.DEBUG and settings.DEBUG_TRACE_STATE:
                latest = status_display_data.sensor_response_list[ 0 ]
                DevOverrideManager.trace_state(
                    'hi.ui_poll.entity_state.out',
                    integration_name = latest.integration_key.integration_name,
                    hi_entity_state_id = status_display_data.entity_state.id,
                    hi_value = latest.value,
                    row = status_map[ state_id_key ],
                )
            continue

        return status_map

    def get_all_entity_state_status_data_list( self ) -> List[ EntityStateStatusData ]:
        """
        Gets the latest sensor responses for all EntityStates.  Used by client
        background polling to refresh the UI visual display of the current
        state.
        """
        
        sensor_to_sensor_response_list = self._get_latest_sensor_responses_helper()
        
        # Since a given EntityState can have zero or more sensors, for each
        # EntityState, we need to collate all the sensor values to find the
        # latest status.
        #
        # For a given EntityState, we do not display multiple sensors if it
        # has them. The display for the state uses an amalgam of all those
        # sensors where the most recent response determines the current
        # state.

        # Collate latest sensor responses by EntityState.
        #
        entity_state_to_sensor_response_list = dict()
        for sensor, sensor_response_list in sensor_to_sensor_response_list.items():
            if sensor.entity_state not in entity_state_to_sensor_response_list:
                entity_state_to_sensor_response_list[sensor.entity_state] = list()
            entity_state_to_sensor_response_list[sensor.entity_state].extend( sensor_response_list )
            continue

        # Find the latest sensor response for each EntityState and create
        # the EntityStateStatusData instance for each.
        #
        entity_state_status_data_list = list()
        for entity_state, sensor_response_list in entity_state_to_sensor_response_list.items():
            sensor_response_list.sort( key = lambda item: item.timestamp, reverse = True )
            latest_sensor_response = sensor_response_list[0]

            controller_data_list = [
                ControllerData(
                    controller = controller,
                    latest_sensor_response = latest_sensor_response,
                )
                for controller in entity_state.controllers.all()
            ]
            entity_state_status_data = EntityStateStatusData(
                entity_state = entity_state,
                sensor_response_list = sensor_response_list,
                controller_data_list = controller_data_list,
                # This branch only sees EntityStates that produced
                # responses, so a sensor must exist; controllers
                # are explicitly known via the list above.
                has_sensor = True,
                has_controller = bool( controller_data_list ),
            )
            entity_state_status_data_list.append( entity_state_status_data )
            continue

        return entity_state_status_data_list

    def get_entity_status_data( self, entity : Entity ) -> EntityStatusData:

        # The set of entity states used to define the state includes the
        # principals when the entity is a delegate.
        #
        entity_for_video = None
        if entity.has_live_feed:
            entity_for_video = entity

        entity_state_set = set( entity.states.all() )
        for entity_state_delegation in entity.entity_state_delegations.all():
            entity_state_set.add( entity_state_delegation.entity_state )
            if ( not entity_for_video
                 and entity_state_delegation.entity_state.entity.has_live_feed ):
                entity_for_video = entity_state_delegation.entity_state.entity
            continue

        entity_state_to_status_data = self._get_entity_state_to_entity_state_status_data(
            entity_states = entity_state_set,
        )

        svg_item_factory = SvgItemFactory()
        svg_icon_item = svg_item_factory.get_display_only_svg_icon_item(
            entity = entity,
        )
        return EntityStatusData(
            entity = entity,
            entity_state_status_data_list = list( entity_state_to_status_data.values() ),
            entity_for_video = entity_for_video,  # Possibly principal entity via delegation
            display_only_svg_icon_item = svg_icon_item,
        )

    def get_entity_status_data_list(
            self,
            entities : Sequence[ Entity ] ) -> List[ EntityStatusData ]:
        """ 
        Same as _get_entity_to_entity_status_data() but returns a List instead of a Dict.
        Preserves the ordering so resulting list in same order as input list.
        """
        
        entity_to_entity_status_data = self._get_entity_to_entity_status_data(
            entities = entities,
        )

        # Reform dict values as a list matching input list order and ensure
        # each entity has EntityStatusData (even if there are no latest
        # sensor responses).
        #
        svg_item_factory = SvgItemFactory()
        entity_status_data_list = list()
        for entity in entities:
            svg_icon_item = svg_item_factory.get_display_only_svg_icon_item(
                entity = entity,
            )
            entity_status_data = entity_to_entity_status_data.get( entity )
            if not entity_status_data:
                entity_status_data = EntityStatusData(
                    entity = entity,
                    entity_state_status_data_list = list(),
                    display_only_svg_icon_item = svg_icon_item,
                    # entity_for_video not looking for delegations here
                )
            else:
                entity_status_data.display_only_svg_icon_item = svg_icon_item
                
            entity_status_data_list.append( entity_status_data )
            continue
        
        return entity_status_data_list
    
    def _get_entity_to_entity_status_data(
            self,
            entities : Sequence[ Entity ] ) -> Dict[ Entity, EntityStatusData ]:

        # Gather all EntityStates for all Entities so we can issue a single
        # fetch of the latest SensorResponses.
        #
        entity_to_entity_state_set = { x: set( x.states.all() ) for x in entities }
        all_entity_states = set()
        for entity, entity_state_set in entity_to_entity_state_set.items():
            all_entity_states.update( entity_state_set )
            for entity_state_delegation in entity.entity_state_delegations.all():
                entity_state_set.add( entity_state_delegation.entity_state )
                all_entity_states.add( entity_state_delegation.entity_state )
                continue
            continue

        # Includes a single fetch for getting all latest sensor data.
        #
        entity_state_to_status_data = self._get_entity_state_to_entity_state_status_data(
            entity_states = all_entity_states,
        )
        
        # Collate EntityStateStatusData by Entity
        #
        entity_to_entity_status_data = dict()
        for entity_state, entity_state_status_data in entity_state_to_status_data.items():
            entity = entity_state.entity
            if entity not in entity_to_entity_status_data:
                entity_status_data = EntityStatusData(
                    entity = entity,
                    entity_state_status_data_list = list()
                    # entity_for_video not looking for delegations here
                    # display_only_svg_icon_item is filled in later
                )
                entity_to_entity_status_data[entity] = entity_status_data
            else:
                entity_status_data = entity_to_entity_status_data[entity]
                
            entity_status_data.entity_state_status_data_list.append(
                entity_state_status_data
            )
            continue

        return entity_to_entity_status_data

    def _get_entity_state_to_entity_state_status_data(
            self,
            entity_states : Sequence[ EntityState ] ) -> Dict[ EntityState, EntityStateStatusData ]:

        # Collect all the sensors for all the input EntityStates, so we can
        # issue one fetch of the latest SensorData.
        #
        entity_state_to_sensor_list = dict()
        all_sensor_list = list()
        for entity_state in entity_states:
            entity_state_sensor_list = list( entity_state.sensors.all() )
            entity_state_to_sensor_list[entity_state] = entity_state_sensor_list
            all_sensor_list.extend( entity_state_sensor_list )
            continue
        
        # Single fetch for getting all latest sensor data.
        #
        sensor_to_sensor_response_list = self._get_latest_sensor_responses_helper(
            sensor_list = all_sensor_list,
        )

        # Collates SensorResponses by EntityState, finds latest
        # SensorResponse and creates the EntityStateStatusData instances.
        #
        entity_state_to_entity_state_status_data_map = dict()
        for entity_state in entity_states:
            entity_state_sensor_response_list = list()
            for sensor in entity_state_to_sensor_list.get( entity_state ):
                sensor_response_list = sensor_to_sensor_response_list.get( sensor )
                if sensor_response_list:
                    entity_state_sensor_response_list.extend( sensor_response_list )
                continue
            entity_state_sensor_response_list.sort( key = lambda item: item.timestamp, reverse = True )

            if entity_state_sensor_response_list:
                latest_sensor_response = entity_state_sensor_response_list[0]
            else:
                latest_sensor_response = None
                
            controller_data_list = list()
            for controller in entity_state.controllers.all():
                controller_data = ControllerData(
                    controller = controller,
                    latest_sensor_response = latest_sensor_response,
                )
                controller_data_list.append( controller_data )
                continue
            
            entity_state_status_data = EntityStateStatusData(
                entity_state = entity_state,
                sensor_response_list = entity_state_sensor_response_list,
                controller_data_list = controller_data_list,
                has_sensor = bool( entity_state_to_sensor_list.get( entity_state ) ),
                has_controller = bool( controller_data_list ),
            )
            entity_state_to_entity_state_status_data_map[entity_state] = entity_state_status_data
            continue
        
        return entity_state_to_entity_state_status_data_map

    def get_entity_to_entity_state_status_data_list(
            self,
            entities       : Set[ Entity ] ) -> Dict[ Entity, List[ EntityStateStatusData ] ]:
        """Builds a map from Entity to its EntityStateStatusData list
        (covering all of the entity's states, including any delegated
        principal states). Per-entity primary-state selection happens
        downstream in ``LocationViewData`` via
        ``ENTITY_PRIMARY_STATE_ORDERING`` — no EntityStateType
        pre-filter is applied here."""

        # Batch-prefetch the relations this flow will walk so the
        # per-entity loop below doesn't issue 2N delegation/states
        # queries and the downstream sensor/controller fetches don't
        # add 2M more.
        prefetch_related_objects(
            list( entities ),
            'states__sensors',
            'states__controllers',
            'entity_state_delegations__entity_state__sensors',
            'entity_state_delegations__entity_state__controllers',
        )

        entity_to_entity_state_list = dict()
        all_entity_states = set()
        for entity in entities:
            entity_states = self.all_entity_states_including_delegations( entity )
            if not entity_states:
                continue
            entity_to_entity_state_list[entity] = entity_states
            all_entity_states.update( entity_states )
            continue

        entity_state_to_status_data = self._get_entity_state_to_entity_state_status_data(
            entity_states = all_entity_states,
        )

        entity_to_entity_state_status_data_list = dict()
        for entity, entity_state_list in entity_to_entity_state_list.items():
            entity_to_entity_state_status_data_list[entity] = list()
            for entity_state in entity_state_list:
                entity_state_status_data = entity_state_to_status_data.get( entity_state )
                if entity_state_status_data:
                    entity_to_entity_state_status_data_list[entity].append( entity_state_status_data )
                continue
            continue

        return entity_to_entity_state_status_data_list

    def all_entity_states_including_delegations(
            self, entity : Entity ) -> List[ EntityState ]:
        """All EntityStates the entity exposes for status display:
        its own ``states`` plus any states delegated from principals
        via ``EntityStateDelegation``. Deduplicated to guard against
        the unusual case of an entity delegating one of its own
        states or two delegations resolving to the same state.

        ``.all()`` is used (not ``.select_related(...).all()``) so
        callers that have prefetched ``entity_state_delegations__
        entity_state`` use the cache. For single-entity callers with
        no prefetch, the additional FK fetch per delegation is
        bounded and acceptable."""
        seen = set()
        result = []
        for d in entity.entity_state_delegations.all():
            if d.entity_state.id in seen:
                continue
            seen.add( d.entity_state.id )
            result.append( d.entity_state )
        for state in entity.states.all():
            if state.id in seen:
                continue
            seen.add( state.id )
            result.append( state )
        return result

    def get_latest_sensor_response( self, entity_state : EntityState ) -> SensorResponse:
        sensor_list = list( entity_state.sensors.all() )
        
        sensor_to_sensor_response_list = self._get_latest_sensor_responses_helper(
            sensor_list = sensor_list,
        )
        entity_state_sensor_response_list = list()
        for sensor in sensor_list:
            sensor_response_list = sensor_to_sensor_response_list.get( sensor )
            if sensor_response_list:
                entity_state_sensor_response_list.extend( sensor_response_list )
            continue
        entity_state_sensor_response_list.sort( key = lambda item: item.timestamp, reverse = True )

        if entity_state_sensor_response_list:
            return entity_state_sensor_response_list[0]

        return None

    def _get_latest_sensor_responses_helper(
            self,
            sensor_list : List[ Sensor ] = None ) -> Dict[ Sensor, List[ SensorResponse ] ] :
        sensor_response_manager = self.sensor_response_manager()
        
        if sensor_list is None:
            sensor_to_sensor_response_list = sensor_response_manager.get_all_latest_sensor_responses()
        else:
            sensor_to_sensor_response_list = sensor_response_manager.get_latest_sensor_responses(
                sensor_list = sensor_list,
            )

        # Dev-only: let the simulator's 'Clear States' drop pre-cutoff
        # responses so lingering recent/past visuals don't block re-runs.
        if settings.DEBUG and getattr( settings, 'DEBUG_FORCE_SENSOR_RESPONSE_CUTOFF', False ):
            sensor_to_sensor_response_list = DevInjectionManager.apply_sensor_response_cutoff(
                sensor_to_sensor_response_list,
            )

        # Apply overrides into a fresh dict so neither the
        # SensorResponse objects nor the response lists owned by
        # SensorResponseManager's cache are touched. Mutating
        # them would persist the override past its TTL.
        result = dict()
        for sensor, sensor_response_list in sensor_to_sensor_response_list.items():
            if ( not sensor_response_list
                 or ( sensor.entity_state.id not in self._status_value_overrides )):
                result[ sensor ] = sensor_response_list
                continue
            overridden = dataclasses.replace(
                sensor_response_list[ 0 ],
                value = self._status_value_overrides[ sensor.entity_state.id ],
            )
            result[ sensor ] = [ overridden, *sensor_response_list[ 1: ] ]
            continue

        return result
        
    def add_entity_state_value_override( self,
                                         entity_state    : EntityState,
                                         override_value  : str ):
        """
        Add a temporary override when values is explicitly chnaged by a controller to
        compensate for the delays in value updates from the polling intervals.
        """
        self._status_value_overrides[entity_state.id] = override_value
        return