Skip to content

Home Information - Your home, your data, organized.

Python
8.3 KB
Raw Blame
from datetime import timedelta
import logging
from typing import List
import pytz

import hi.apps.common.datetimeproxy as datetimeproxy
from hi.apps.console.console_helper import ConsoleSettingsHelper

from .transient_models import (
    DataPointSource,
    TimeInterval,
    IntervalEnvironmentalData,
)
from .aggregated_weather_data import AggregatedWeatherData

logger = logging.getLogger(__name__)


class IntervalDataManager:

    INTERVAL_MATCH_OVERLAP_THRESHOLD = 0.4
    INTERVAL_NEW_FRACTION_THRESHOLD = 0.6

    TRACE = False  # For debugging
    
    def __init__( self,
                  interval_hours      : int,
                  max_interval_count  : int,
                  is_order_ascending  : bool,
                  data_class          : type ):
        self._interval_hours = interval_hours
        self._max_interval_count = max_interval_count
        self._is_order_ascending = is_order_ascending 
        self._data_class = data_class
        self._aggregated_interval_data_list = list()
        self._was_initialized = False

        # Daily intervals (24h) use local-timezone day boundaries;
        # hourly intervals use UTC boundaries.
        self._use_local_timezone = (interval_hours == 24)
        if self._use_local_timezone:
            self._console_helper = ConsoleSettingsHelper()
        return

    def ensure_initialized(self):
        if self._was_initialized:
            return
        try:
            self._initialize()
        except Exception as e:
            logger.exception( 'Problem trying to initialize time interval data', e )
        self._was_initialized = True
        return
   
    def _initialize(self):
        self._update_intervals()
        return

    def add_data( self,
                  data_point_source       : DataPointSource,
                  new_interval_data_list  : List[ IntervalEnvironmentalData ] ):

        # Update intervals first to handle time passage (remove old, add new intervals)
        self._update_intervals()

        self._add_source_data_to_interval_data(
            data_point_source = data_point_source,
            source_interval_data_list = new_interval_data_list,
        )
        for aggregated_interval_data in self._aggregated_interval_data_list:
            aggregated_interval_data.reaggregate_source_data()
            continue
        return
        
    def _add_source_data_to_interval_data( self,
                                           data_point_source          : DataPointSource,
                                           source_interval_data_list  : List[ IntervalEnvironmentalData ] ):
        """ Distribute source interval data into the existing aggregate intervals it overlaps with. """

        if self.TRACE:
            logger.debug( f'Adding interval data from:'
                          f' {data_point_source.id} [{len(source_interval_data_list)} intervals]' )
            
        for source_interval_data in source_interval_data_list:
            for aggregated_interval_data in self._aggregated_interval_data_list:
                existing_interval = aggregated_interval_data.interval_data.interval
                overlaps = existing_interval.overlaps( source_interval_data.interval )
                if overlaps:
                    aggregated_interval_data.add_source_data(
                        data_point_source = data_point_source,
                        source_interval_data = source_interval_data,
                    )
                continue
            continue
        return
        
    def _update_intervals( self ):
        """ Adjust the intervals based on current time (truncating old, adding new) """
        
        existing_aggregated_interval_data_map = dict()
        for aggregated_interval_data in self._aggregated_interval_data_list:
            time_interval = aggregated_interval_data.interval_data.interval
            existing_aggregated_interval_data_map[time_interval] = aggregated_interval_data
            continue

        new_aggregated_interval_data_list = list()
        new_time_interval_list = self._get_calculated_intervals()

        for new_time_interval in new_time_interval_list:
            if new_time_interval in existing_aggregated_interval_data_map:
                aggregated_interval_data = existing_aggregated_interval_data_map[new_time_interval]
            else:
                aggregated_interval_data = AggregatedWeatherData.from_time_interval(
                    time_interval = new_time_interval,
                    data_class = self._data_class,
                )
            new_aggregated_interval_data_list.append( aggregated_interval_data )
            continue

        self._aggregated_interval_data_list = new_aggregated_interval_data_list
        return
        
    def _get_calculated_intervals( self ):
        """ Create the intervals needed for the current time. """

        if self._use_local_timezone:
            return self._get_calculated_intervals_local_timezone()
        else:
            return self._get_calculated_intervals_utc()

    def _get_calculated_intervals_utc( self ):
        """ Create UTC-based intervals (for hourly forecasts). """

        now = datetimeproxy.now()
        
        rounded_start = now.replace(
            minute = 0, second = 0, microsecond = 0
        ) - timedelta( hours = now.hour % self._interval_hours )
        
        if ( now == rounded_start ) and not self._is_order_ascending:
            rounded_start -= timedelta( hours = self._interval_hours )  

        time_interval_list = list()

        for idx in range( self._max_interval_count ):
            if self._is_order_ascending:
                interval_start = rounded_start + timedelta( hours = idx * self._interval_hours )
                interval_end = rounded_start + timedelta( hours = ( idx + 1 ) * self._interval_hours )
            else:
                interval_end = rounded_start - timedelta( hours = idx * self._interval_hours )
                interval_start = rounded_start - timedelta( hours = ( idx + 1 ) * self._interval_hours )

            time_interval = TimeInterval(
                start = interval_start,
                end = interval_end,
            )
            time_interval_list.append( time_interval )
            continue

        return time_interval_list
    
    def _get_calculated_intervals_local_timezone( self ):
        """ Create local timezone-based intervals (for daily forecasts). """

        user_timezone = self._console_helper.get_tz_name()
        local_tz = pytz.timezone(user_timezone)
        utc_now = datetimeproxy.now()
        local_now = utc_now.astimezone(local_tz)

        if self.TRACE:
            logger.debug(f'Creating daily intervals for timezone: {user_timezone}')
            logger.debug(f'UTC now: {utc_now}')
            logger.debug(f'Local now: {local_now}')

        local_day_start = local_now.replace(hour=0, minute=0, second=0, microsecond=0)

        if not self._is_order_ascending:
            local_day_start = local_day_start  # Keep today's start for calculation reference

        time_interval_list = list()

        for idx in range( self._max_interval_count ):
            if self._is_order_ascending:
                local_interval_start = local_day_start + timedelta(days=idx)
                local_interval_end = local_day_start + timedelta(days=idx + 1)
            else:
                # idx=0 is yesterday, idx=1 is day before yesterday, etc.
                local_interval_start = local_day_start - timedelta(days=idx + 1)
                local_interval_end = local_day_start - timedelta(days=idx)

            # Convert local timezone boundaries back to UTC for internal storage
            utc_interval_start = local_interval_start.astimezone(pytz.UTC)
            utc_interval_end = local_interval_end.astimezone(pytz.UTC)
            
            time_interval = TimeInterval(
                start = utc_interval_start,
                end = utc_interval_end,
            )
            time_interval_list.append( time_interval )
            continue

        if self.TRACE:
            logger.debug(f'Created {len(time_interval_list)} daily intervals')
            for i, interval in enumerate(time_interval_list):
                local_start = interval.start.astimezone(local_tz)
                local_end = interval.end.astimezone(local_tz)
                logger.debug(f'  Interval {i}: {local_start.date()} to {local_end.date()} (local)')

        return time_interval_list