window-time 0.1.0__py3-none-any.whl

window_time/daemon.py

@@ -0,0 +1,156 @@
+"""Daemon runner for periodic temperature monitoring."""
+
+import logging
+import signal
+import time
+from datetime import datetime
+from typing import Optional
+
+from .config import Config
+from .influxdb_client import TemperatureClient
+from .notifications import notify_window_action
+from .temperature_analysis import analyze_temperatures
+from .window_state import (
+    DailyState,
+    WindowAction,
+    load_state,
+    make_window_decision,
+    save_state,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WindowTimeDaemon:
+    """Daemon that monitors temperatures and notifies about window actions."""
+
+    def __init__(self, config: Config):
+        """Initialize the daemon.
+
+        Args:
+            config: Application configuration.
+        """
+        self.config = config
+        self.running = False
+        self._setup_signal_handlers()
+
+    def _setup_signal_handlers(self) -> None:
+        """Set up signal handlers for graceful shutdown."""
+        signal.signal(signal.SIGTERM, self._handle_signal)
+        signal.signal(signal.SIGINT, self._handle_signal)
+
+    def _handle_signal(self, signum: int, frame) -> None:
+        """Handle shutdown signals.
+
+        Args:
+            signum: Signal number.
+            frame: Current stack frame.
+        """
+        logger.info(f"Received signal {signum}, shutting down...")
+        self.running = False
+
+    def run_once(self, state: Optional[DailyState] = None) -> DailyState:
+        """Run a single iteration of the temperature check.
+
+        Args:
+            state: Current daily state. If None, loads from file.
+
+        Returns:
+            Updated daily state.
+        """
+        logger.info(f"Running temperature check at {datetime.now().isoformat()}")
+
+        # Load state if not provided
+        if state is None:
+            state = load_state()
+
+        try:
+            # Fetch temperature data
+            with TemperatureClient(self.config) as client:
+                temp_data = client.fetch_temperature_data(
+                    lookback_hours=self.config.daemon.lookback_hours
+                )
+
+            if not temp_data.has_data:
+                logger.warning("No temperature data available")
+                return state
+
+            # Analyze temperatures
+            analysis = analyze_temperatures(temp_data)
+
+            logger.info(
+                f"Current temps - Indoor: {analysis.current_indoor_temp:.1f}° "
+                f"Outdoor: {analysis.current_outdoor_temp:.1f}°"
+            )
+
+            if analysis.indoor_trend:
+                logger.info(
+                    f"Indoor trend: {analysis.indoor_trend.direction.value} "
+                    f"({analysis.indoor_trend.rate_per_hour:+.2f}°/hr)"
+                )
+
+            if analysis.outdoor_trend:
+                logger.info(
+                    f"Outdoor trend: {analysis.outdoor_trend.direction.value} "
+                    f"({analysis.outdoor_trend.rate_per_hour:+.2f}°/hr)"
+                )
+
+            if analysis.crossing_prediction and analysis.crossing_prediction.will_cross:
+                logger.info(
+                    f"Temperatures predicted to cross in "
+                    f"{analysis.crossing_prediction.minutes_until_crossing:.0f} minutes "
+                    f"at {analysis.crossing_prediction.crossing_temp:.1f}°"
+                )
+
+            # Make window decision
+            decision, new_state = make_window_decision(analysis, state, self.config)
+
+            if decision.action != WindowAction.NO_ACTION:
+                logger.info(f"Window action: {decision.action.value} - {decision.reason}")
+                notify_window_action(self.config, decision)
+            else:
+                logger.debug(f"No action needed: {decision.reason}")
+
+            # Save updated state
+            save_state(new_state)
+
+            return new_state
+
+        except Exception as e:
+            logger.error(f"Error during temperature check: {e}", exc_info=True)
+            return state
+
+    def run(self) -> None:
+        """Run the daemon loop."""
+        logger.info("Starting window-time daemon")
+        logger.info(f"Check interval: {self.config.daemon.interval_minutes} minutes")
+
+        self.running = True
+        state = load_state()
+
+        while self.running:
+            state = self.run_once(state)
+
+            if not self.running:
+                break
+
+            # Sleep for the configured interval
+            sleep_seconds = self.config.daemon.interval_minutes * 60
+            logger.debug(f"Sleeping for {sleep_seconds} seconds")
+
+            # Sleep in small increments to respond to signals quickly
+            sleep_end = time.time() + sleep_seconds
+            while self.running and time.time() < sleep_end:
+                time.sleep(min(1.0, sleep_end - time.time()))
+
+        logger.info("Daemon stopped")
+
+
+def run_daemon(config: Config) -> None:
+    """Run the window-time daemon.
+
+    Args:
+        config: Application configuration.
+    """
+    daemon = WindowTimeDaemon(config)
+    daemon.run()

window_time/influxdb_client.py

@@ -0,0 +1,155 @@
+"""InfluxDB client for fetching temperature data."""
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from influxdb_client import InfluxDBClient
+
+from .config import Config
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TemperatureReading:
+    """A single temperature reading from a sensor."""
+
+    timestamp: datetime
+    temperature: float
+    domain: str
+    location: str
+    mac: str
+
+
+@dataclass
+class TemperatureData:
+    """Collection of temperature readings separated by domain."""
+
+    indoor_readings: list[TemperatureReading]
+    outdoor_readings: list[TemperatureReading]
+
+    @property
+    def has_data(self) -> bool:
+        """Check if there is any temperature data."""
+        return bool(self.indoor_readings) and bool(self.outdoor_readings)
+
+
+class TemperatureClient:
+    """Client for fetching temperature data from InfluxDB."""
+
+    def __init__(self, config: Config):
+        """Initialize the temperature client.
+
+        Args:
+            config: Application configuration containing InfluxDB settings.
+        """
+        self.config = config
+        self._client: Optional[InfluxDBClient] = None
+
+    def _get_client(self) -> InfluxDBClient:
+        """Get or create the InfluxDB client."""
+        if self._client is None:
+            self._client = InfluxDBClient(
+                url=self.config.influxdb.url,
+                token=self.config.influxdb.token,
+                org=self.config.influxdb.org,
+            )
+        return self._client
+
+    def close(self) -> None:
+        """Close the InfluxDB client connection."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    def fetch_temperature_data(self, lookback_hours: int = 1) -> TemperatureData:
+        """Fetch temperature data from InfluxDB.
+
+        Args:
+            lookback_hours: Number of hours to look back for data.
+
+        Returns:
+            TemperatureData containing indoor and outdoor readings.
+        """
+        client = self._get_client()
+        query_api = client.query_api()
+
+        influx_config = self.config.influxdb
+
+        indoor = influx_config.indoor_domain
+        outdoor = influx_config.outdoor_domain
+        domain = influx_config.domain_tag
+
+        query = f'''
+        from(bucket: "{influx_config.bucket}")
+            |> range(start: -{lookback_hours}h)
+            |> filter(fn: (r) => r["_measurement"] == "{influx_config.measurement}")
+            |> filter(fn: (r) => r["_field"] == "{influx_config.temperature_field}")
+            |> filter(fn: (r) => r["{domain}"] == "{indoor}" or r["{domain}"] == "{outdoor}")
+            |> sort(columns: ["_time"])
+        '''
+
+        logger.debug(f"Executing InfluxDB query:\n{query}")
+
+        try:
+            tables = query_api.query(query)
+        except Exception as e:
+            logger.error(f"Error querying InfluxDB: {e}")
+            raise
+
+        indoor_readings: list[TemperatureReading] = []
+        outdoor_readings: list[TemperatureReading] = []
+
+        for table in tables:
+            for record in table.records:
+                reading = TemperatureReading(
+                    timestamp=record.get_time(),
+                    temperature=float(record.get_value()),
+                    domain=record.values.get(influx_config.domain_tag, ""),
+                    location=record.values.get(influx_config.location_tag, ""),
+                    mac=record.values.get(influx_config.mac_tag, ""),
+                )
+
+                if reading.domain == influx_config.indoor_domain:
+                    indoor_readings.append(reading)
+                elif reading.domain == influx_config.outdoor_domain:
+                    outdoor_readings.append(reading)
+
+        logger.info(
+            f"Fetched {len(indoor_readings)} indoor and {len(outdoor_readings)} outdoor readings"
+        )
+
+        return TemperatureData(
+            indoor_readings=indoor_readings,
+            outdoor_readings=outdoor_readings,
+        )
+
+    def get_current_temperatures(self) -> tuple[Optional[float], Optional[float]]:
+        """Get the most recent indoor and outdoor temperatures.
+
+        Returns:
+            Tuple of (indoor_temp, outdoor_temp), either may be None if no data.
+        """
+        data = self.fetch_temperature_data(lookback_hours=1)
+
+        indoor_temp = None
+        outdoor_temp = None
+
+        if data.indoor_readings:
+            indoor_temp = data.indoor_readings[-1].temperature
+
+        if data.outdoor_readings:
+            outdoor_temp = data.outdoor_readings[-1].temperature
+
+        return indoor_temp, outdoor_temp
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+        return False

window_time/notifications.py

@@ -0,0 +1,118 @@
+"""Notification system using ntfy.sh."""
+
+import logging
+from typing import Optional
+
+import requests
+
+from .config import Config
+from .window_state import WindowAction, WindowDecision
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationError(Exception):
+    """Error sending notification."""
+
+    pass
+
+
+def send_notification(
+    config: Config,
+    title: str,
+    message: str,
+    priority: str = "default",
+    tags: Optional[list[str]] = None,
+) -> bool:
+    """Send a notification via ntfy.sh.
+
+    Args:
+        config: Application configuration with ntfy settings.
+        title: Notification title.
+        message: Notification message body.
+        priority: Notification priority (min, low, default, high, urgent).
+        tags: Optional list of emoji tags for the notification.
+
+    Returns:
+        True if notification was sent successfully.
+
+    Raises:
+        NotificationError: If notification fails to send.
+    """
+    if not config.notification.ntfy_topic:
+        logger.warning("No ntfy topic configured, skipping notification")
+        return False
+
+    url = f"{config.notification.ntfy_server}/{config.notification.ntfy_topic}"
+
+    headers = {
+        "Title": title,
+        "Priority": priority,
+    }
+
+    if tags:
+        headers["Tags"] = ",".join(tags)
+
+    try:
+        response = requests.post(url, data=message.encode("utf-8"), headers=headers)
+        response.raise_for_status()
+        logger.info(f"Notification sent: {title}")
+        return True
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to send notification: {e}")
+        raise NotificationError(f"Failed to send notification: {e}") from e
+
+
+def notify_window_action(config: Config, decision: WindowDecision) -> bool:
+    """Send a notification for a window action decision.
+
+    Args:
+        config: Application configuration.
+        decision: The window decision to notify about.
+
+    Returns:
+        True if notification was sent successfully.
+    """
+    if decision.action == WindowAction.NO_ACTION:
+        logger.debug("No window action needed, skipping notification")
+        return False
+
+    # Format temperatures
+    indoor = (
+        f"{decision.current_indoor_temp:.1f}°"
+        if decision.current_indoor_temp is not None
+        else "N/A"
+    )
+    outdoor = (
+        f"{decision.current_outdoor_temp:.1f}°"
+        if decision.current_outdoor_temp is not None
+        else "N/A"
+    )
+
+    if decision.action == WindowAction.OPEN:
+        title = "Time to Open the Windows!"
+        tags = ["house", "sunny"]
+        priority = "high"
+    else:  # CLOSE
+        title = "Time to Close the Windows!"
+        tags = ["house", "closed_lock_with_key"]
+        priority = "high"
+
+    message = (
+        f"{decision.reason}\n\n"
+        f"Indoor: {indoor}\n"
+        f"Outdoor: {outdoor}\n"
+        f"Season: {decision.season.value.capitalize()}"
+    )
+
+    try:
+        return send_notification(
+            config,
+            title=title,
+            message=message,
+            priority=priority,
+            tags=tags,
+        )
+    except NotificationError:
+        # Error already logged, return False
+        return False

window_time/season.py

@@ -0,0 +1,68 @@
+"""Season detection for determining summer vs winter window behavior."""
+
+from datetime import date
+from enum import Enum
+
+from .config import SeasonConfig
+
+
+class Season(Enum):
+    """Season enumeration."""
+
+    SUMMER = "summer"
+    WINTER = "winter"
+
+
+def get_season(current_date: date, config: SeasonConfig) -> Season:
+    """Determine the current season based on date.
+
+    Summer: April 8 to November 11 (inclusive)
+    Winter: November 12 to April 7 (inclusive)
+
+    Args:
+        current_date: The date to check.
+        config: Season configuration with boundary dates.
+
+    Returns:
+        The current season.
+    """
+    month = current_date.month
+    day = current_date.day
+
+    # Create comparable (month, day) tuples
+    current = (month, day)
+    summer_start = (config.summer_start_month, config.summer_start_day)
+    summer_end = (config.summer_end_month, config.summer_end_day)
+
+    # Summer is from April 8 to November 11
+    # Winter is from November 12 to April 7
+    if summer_start <= current <= summer_end:
+        return Season.SUMMER
+    else:
+        return Season.WINTER
+
+
+def is_summer(current_date: date, config: SeasonConfig) -> bool:
+    """Check if the current date is in summer.
+
+    Args:
+        current_date: The date to check.
+        config: Season configuration with boundary dates.
+
+    Returns:
+        True if it's summer, False otherwise.
+    """
+    return get_season(current_date, config) == Season.SUMMER
+
+
+def is_winter(current_date: date, config: SeasonConfig) -> bool:
+    """Check if the current date is in winter.
+
+    Args:
+        current_date: The date to check.
+        config: Season configuration with boundary dates.
+
+    Returns:
+        True if it's winter, False otherwise.
+    """
+    return get_season(current_date, config) == Season.WINTER