Home Information - Your home, your data, organized.
Python
import logging
from threading import local
from typing import List, Sequence
from django.db import transaction
from django.db.models import QuerySet
from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from hi.apps.common.singleton import Singleton
from hi.apps.location.models import LocationView
from .entity_pairing_manager import EntityPairingManager
from .entity_placement import EntityPlacer
from .enums import EntityGroupType
from .models import (
Entity,
EntityAttribute,
EntityPath,
EntityPosition,
EntityState,
EntityStateDelegation,
EntityView,
)
from .transient_models import (
EntityEditModeData,
EntityViewGroup,
EntityViewItem,
LocationViewEntityPickerData,
)
logger = logging.getLogger(__name__)
class EntityManager(Singleton):
"""Entity-domain coordination: edit-mode data assembly, view-group
rendering, capability listings, and the change-listener registry.
Initial entity placement, persistence of EntityPosition /
EntityPath rows, and entity-type transitions all live in
``hi.apps.entity.entity_placement``."""
def __init_singleton__(self):
self._change_listeners = list()
self.reload()
return
def reload(self):
self._notify_change_listeners()
return
def register_change_listener( self, callback ):
logger.debug( f'Adding EntityManager change listener from {callback.__module__}' )
self._change_listeners.append( callback )
return
def _notify_change_listeners(self):
for callback in self._change_listeners:
try:
callback()
except Exception as e:
logger.exception( 'Problem calling EntityManager change callback.', e )
continue
return
def get_entity_edit_mode_data( self,
entity : Entity,
location_view : LocationView,
is_editing : bool ) -> EntityEditModeData:
entity_position_form = None
if is_editing:
entity_position_form = EntityPlacer().get_entity_position_form(
entity = entity,
location_view = location_view,
)
entity_pairing_list = EntityPairingManager().get_entity_pairing_list( entity = entity )
return EntityEditModeData(
entity = entity,
entity_position_form = entity_position_form,
entity_pairing_list = entity_pairing_list,
)
def create_location_entity_view_group_list( self,
location_view : LocationView,
unused_entity_ids : set = None,
exclude_delegates : bool = False,
) -> List[EntityViewGroup]:
existing_entities = [ x.entity
for x in location_view.entity_views.select_related('entity').all() ]
all_entities = Entity.objects.all()
if exclude_delegates:
all_entities = all_entities.exclude(
entity_state_delegations__isnull = False,
)
return self.create_entity_view_group_list(
existing_entities = existing_entities,
all_entities = all_entities,
unused_entity_ids = unused_entity_ids,
)
def create_location_entity_picker_data( self,
location_view : LocationView,
unused_entity_ids : set = None,
) -> LocationViewEntityPickerData:
"""Build both LocationView item-picker sections in a single entity
scan: the type-grouped non-delegate entities and the flat delegate
("Paired Items") list. Replaces a separate query per section --
the entities are loaded once and partitioned in Python by whether
they act as a delegate, sharing one ``entity_views`` lookup."""
if unused_entity_ids is None:
unused_entity_ids = set()
existing_entities = [ x.entity
for x in location_view.entity_views.select_related('entity').all() ]
existing_entity_id_set = { x.id for x in existing_entities }
delegate_entity_id_set = set(
EntityStateDelegation.objects.values_list( 'delegate_entity_id', flat = True ).distinct()
)
all_entities = list( Entity.objects.all() )
non_delegate_entities = [ entity for entity in all_entities
if entity.id not in delegate_entity_id_set ]
entity_view_group_list = self.create_entity_view_group_list(
existing_entities = existing_entities,
all_entities = non_delegate_entities,
unused_entity_ids = unused_entity_ids,
)
delegate_view_item_list = [
EntityViewItem(
entity = entity,
exists_in_view = entity.id in existing_entity_id_set,
is_unused = entity.id in unused_entity_ids,
)
for entity in all_entities if entity.id in delegate_entity_id_set
]
delegate_view_item_list.sort( key = lambda item : item.entity.name )
return LocationViewEntityPickerData(
entity_view_group_list = entity_view_group_list,
delegate_view_item_list = delegate_view_item_list,
)
def create_entity_view_group_list( self,
existing_entities : List[ Entity ],
all_entities : Sequence[ Entity ],
unused_entity_ids : set = None ) -> List[EntityViewGroup]:
existing_entity_set = set( existing_entities )
if unused_entity_ids is None:
unused_entity_ids = set()
entity_view_group_dict = dict()
for entity in all_entities:
entity_view_item = EntityViewItem(
entity = entity,
exists_in_view = bool( entity in existing_entity_set ),
is_unused = entity.id in unused_entity_ids,
)
entity_group_type = EntityGroupType.from_entity_type( entity.entity_type )
if entity_group_type not in entity_view_group_dict:
entity_view_group = EntityViewGroup(
entity_group_type = entity_group_type,
)
entity_view_group_dict[entity_group_type] = entity_view_group
entity_view_group_dict[entity_group_type].item_list.append( entity_view_item )
continue
for entity_group_type, entity_view_group in entity_view_group_dict.items():
entity_view_group.item_list.sort( key = lambda item : item.entity.name )
continue
entity_view_group_list = list( entity_view_group_dict.values() )
entity_view_group_list.sort( key = lambda item : item.entity_group_type.label )
return entity_view_group_list
def get_displayable_live_view_entities(self) -> QuerySet[ Entity ]:
"""Queryset of entities that have any current visual (native
stream, synthetic snapshot stream, or static snapshot) AND are
not currently disabled. Used by surfaces that enumerate
"cameras to show" (e.g., the console sidebar). Returned as a
queryset so callers can add their own prefetch / ordering."""
return Entity.objects.with_live_view().filter( is_disabled = False )
_thread_local = local()
def do_entity_manager_reload():
logger.debug( 'Reloading EntityManager from model changes.')
EntityManager().reload()
_thread_local.reload_registered = False
return
@receiver( post_save, sender = Entity )
@receiver( post_save, sender = EntityState )
@receiver( post_save, sender = EntityAttribute )
@receiver( post_save, sender = EntityStateDelegation )
@receiver( post_save, sender = EntityPosition )
@receiver( post_save, sender = EntityPath )
@receiver( post_save, sender = EntityView )
@receiver( post_delete, sender = Entity )
@receiver( post_delete, sender = EntityState )
@receiver( post_delete, sender = EntityAttribute )
@receiver( post_delete, sender = EntityStateDelegation )
@receiver( post_delete, sender = EntityPosition )
@receiver( post_delete, sender = EntityPath )
@receiver( post_delete, sender = EntityView )
def entity_manager_model_changed( sender, instance, **kwargs ):
"""
Queue the EntityManager.reload() call to execute after the transaction
is committed. This prevents reloading multiple times if multiple
models saved as part of a transaction.
"""
if not hasattr(_thread_local, "reload_registered"):
_thread_local.reload_registered = False
logger.debug( 'EntityManager model change detected.')
if not _thread_local.reload_registered:
logger.debug( 'Queuing EntityManager reload on model change.')
_thread_local.reload_registered = True
transaction.on_commit( do_entity_manager_reload )
return