window-time 0.1.0__py3-none-any.whl

window_time/__init__.py

@@ -0,0 +1,3 @@
+"""Window Time - Temperature-based window management notifications."""
+
+__version__ = "0.1.0"

window_time/__main__.py

@@ -0,0 +1,8 @@
+"""Allow running as python -m window_time."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

window_time/cli.py

@@ -0,0 +1,361 @@
+"""Command-line interface for window-time."""
+
+import argparse
+import logging
+import sys
+from datetime import date
+from pathlib import Path
+
+from . import __version__
+from .config import (
+    Config,
+    get_config_path,
+    get_state_path,
+    load_config,
+    save_default_config,
+)
+from .daemon import WindowTimeDaemon, run_daemon
+from .season import get_season
+
+
+def setup_logging(verbose: bool = False, debug: bool = False) -> None:
+    """Configure logging for the application.
+
+    Args:
+        verbose: Enable verbose output.
+        debug: Enable debug output.
+    """
+    if debug:
+        level = logging.DEBUG
+    elif verbose:
+        level = logging.INFO
+    else:
+        level = logging.WARNING
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+def cmd_run(args: argparse.Namespace, config: Config) -> int:
+    """Run the daemon.
+
+    Args:
+        args: Parsed command-line arguments.
+        config: Application configuration.
+
+    Returns:
+        Exit code.
+    """
+    run_daemon(config)
+    return 0
+
+
+def cmd_once(args: argparse.Namespace, config: Config) -> int:
+    """Run a single temperature check.
+
+    Args:
+        args: Parsed command-line arguments.
+        config: Application configuration.
+
+    Returns:
+        Exit code.
+    """
+    daemon = WindowTimeDaemon(config)
+    daemon.run_once()
+    return 0
+
+
+def cmd_status(args: argparse.Namespace, config: Config) -> int:
+    """Show current status and temperatures.
+
+    Args:
+        args: Parsed command-line arguments.
+        config: Application configuration.
+
+    Returns:
+        Exit code.
+    """
+    from .influxdb_client import TemperatureClient
+    from .temperature_analysis import analyze_temperatures
+    from .window_state import load_state
+
+    print("Window Time Status")
+    print("==================")
+    print()
+
+    # Show season
+    today = date.today()
+    season = get_season(today, config.season)
+    print(f"Date: {today.isoformat()}")
+    print(f"Season: {season.value.capitalize()}")
+    print()
+
+    # Show current state
+    state = load_state()
+    print("Window State")
+    print("------------")
+    print(f"Last known state: {state.last_known_state.value}")
+    print(f"Windows opened for warmth today: {state.windows_opened_for_warmth}")
+    if state.last_outdoor_warmer is not None:
+        outdoor_status = "warmer" if state.last_outdoor_warmer else "cooler"
+        print(f"Last check: Outdoor was {outdoor_status} than indoor")
+    print()
+
+    # Fetch and show temperatures
+    print("Current Temperatures")
+    print("--------------------")
+    try:
+        with TemperatureClient(config) as client:
+            temp_data = client.fetch_temperature_data(lookback_hours=config.daemon.lookback_hours)
+
+        if not temp_data.has_data:
+            print("No temperature data available")
+            return 1
+
+        analysis = analyze_temperatures(temp_data)
+
+        if analysis.current_indoor_temp is not None:
+            print(f"Indoor: {analysis.current_indoor_temp:.1f}°")
+        if analysis.current_outdoor_temp is not None:
+            print(f"Outdoor: {analysis.current_outdoor_temp:.1f}°")
+
+        if analysis.outdoor_warmer:
+            print("Outdoor is currently WARMER than indoor")
+        else:
+            print("Outdoor is currently COOLER than indoor")
+
+        print()
+        print("Temperature Trends")
+        print("------------------")
+        if analysis.indoor_trend:
+            print(
+                f"Indoor: {analysis.indoor_trend.direction.value} "
+                f"({analysis.indoor_trend.rate_per_hour:+.2f}°/hr)"
+            )
+        if analysis.outdoor_trend:
+            print(
+                f"Outdoor: {analysis.outdoor_trend.direction.value} "
+                f"({analysis.outdoor_trend.rate_per_hour:+.2f}°/hr)"
+            )
+
+        if analysis.crossing_prediction and analysis.crossing_prediction.will_cross:
+            print()
+            print("Crossing Prediction")
+            print("-------------------")
+            print(
+                f"Temperatures will cross in "
+                f"{analysis.crossing_prediction.minutes_until_crossing:.0f} minutes"
+            )
+            print(f"Crossing temperature: {analysis.crossing_prediction.crossing_temp:.1f}°")
+            if analysis.crossing_prediction.crossing_time:
+                print(
+                    f"Crossing time: {analysis.crossing_prediction.crossing_time.strftime('%H:%M')}"
+                )
+
+    except Exception as e:
+        print(f"Error fetching temperature data: {e}")
+        return 1
+
+    return 0
+
+
+def cmd_init(args: argparse.Namespace, config: Config) -> int:
+    """Initialize configuration file.
+
+    Args:
+        args: Parsed command-line arguments.
+        config: Application configuration.
+
+    Returns:
+        Exit code.
+    """
+    config_path = Path(args.config) if args.config else None
+
+    if config_path and config_path.exists():
+        print(f"Configuration file already exists at {config_path}")
+        if not args.force:
+            print("Use --force to overwrite")
+            return 1
+
+    saved_path = save_default_config(config_path)
+    print(f"Configuration file created at {saved_path}")
+    print()
+    print("Please edit the configuration file to add your:")
+    print("  - InfluxDB token")
+    print("  - ntfy.sh topic ID")
+    print("  - Any other custom settings")
+    return 0
+
+
+def cmd_config(args: argparse.Namespace, config: Config) -> int:
+    """Show configuration paths and current settings.
+
+    Args:
+        args: Parsed command-line arguments.
+        config: Application configuration.
+
+    Returns:
+        Exit code.
+    """
+    print("Configuration Paths")
+    print("===================")
+    print(f"Config file: {get_config_path()}")
+    print(f"State file: {get_state_path()}")
+    print()
+
+    if args.show_values:
+        print("Current Configuration")
+        print("=====================")
+        print()
+        print("InfluxDB:")
+        print(f"  URL: {config.influxdb.url}")
+        print(f"  Organization: {config.influxdb.org}")
+        print(f"  Bucket: {config.influxdb.bucket}")
+        print(f"  Measurement: {config.influxdb.measurement}")
+        print(f"  Token: {'[set]' if config.influxdb.token else '[not set]'}")
+        print()
+        print("Notification:")
+        print(f"  Server: {config.notification.ntfy_server}")
+        print(f"  Topic: {config.notification.ntfy_topic or '[not set]'}")
+        print()
+        print("Season Boundaries:")
+        print(
+            f"  Summer: {config.season.summer_start_month}/{config.season.summer_start_day} "
+            f"to {config.season.summer_end_month}/{config.season.summer_end_day}"
+        )
+        print()
+        print("Daemon:")
+        print(f"  Interval: {config.daemon.interval_minutes} minutes")
+        print(f"  Lookback: {config.daemon.lookback_hours} hour(s)")
+
+    return 0
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the argument parser.
+
+    Returns:
+        Configured ArgumentParser.
+    """
+    parser = argparse.ArgumentParser(
+        prog="window-time",
+        description="Monitor indoor/outdoor temperatures and notify when to open or close windows",
+    )
+
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        metavar="PATH",
+        help="Path to configuration file (default: XDG config location)",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+    )
+
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug output",
+    )
+
+    subparsers = parser.add_subparsers(
+        title="commands",
+        dest="command",
+        metavar="COMMAND",
+    )
+
+    # run command (default)
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run the daemon (default command)",
+    )
+    run_parser.set_defaults(func=cmd_run)
+
+    # once command
+    once_parser = subparsers.add_parser(
+        "once",
+        help="Run a single temperature check and exit",
+    )
+    once_parser.set_defaults(func=cmd_once)
+
+    # status command
+    status_parser = subparsers.add_parser(
+        "status",
+        help="Show current status and temperatures",
+    )
+    status_parser.set_defaults(func=cmd_status)
+
+    # init command
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize configuration file",
+    )
+    init_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Overwrite existing configuration file",
+    )
+    init_parser.set_defaults(func=cmd_init)
+
+    # config command
+    config_parser = subparsers.add_parser(
+        "config",
+        help="Show configuration paths and settings",
+    )
+    config_parser.add_argument(
+        "-s",
+        "--show-values",
+        action="store_true",
+        help="Show current configuration values",
+    )
+    config_parser.set_defaults(func=cmd_config)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Main entry point.
+
+    Args:
+        argv: Command-line arguments. If None, uses sys.argv.
+
+    Returns:
+        Exit code.
+    """
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    setup_logging(verbose=args.verbose, debug=args.debug)
+
+    # Load configuration
+    config_path = Path(args.config) if args.config else None
+    try:
+        config = load_config(config_path)
+    except Exception as e:
+        print(f"Error loading configuration: {e}", file=sys.stderr)
+        return 1
+
+    # Default to 'run' command if no command specified
+    if args.command is None:
+        args.func = cmd_run
+
+    return args.func(args, config)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

window_time/config.py

@@ -0,0 +1,246 @@
+"""Configuration management using platformdirs for XDG-compliant paths."""
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import platformdirs
+import yaml
+
+APP_NAME = "window-time"
+APP_AUTHOR = "Gene Wood"
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class InfluxDBConfig:
+    """InfluxDB connection configuration."""
+
+    url: str = "https://influxdb.example.com"
+    token: str = ""
+    org: str = "my-org"
+    bucket: str = "home"
+    measurement: str = "environment"
+    temperature_field: str = "temperature"
+    domain_tag: str = "domain"
+    location_tag: str = "location"
+    mac_tag: str = "mac"
+    indoor_domain: str = "indoors"
+    outdoor_domain: str = "outdoors"
+
+
+@dataclass
+class NotificationConfig:
+    """Notification configuration for ntfy.sh."""
+
+    ntfy_topic: str = ""
+    ntfy_server: str = "https://ntfy.sh"
+
+
+@dataclass
+class SeasonConfig:
+    """Season date boundaries configuration."""
+
+    summer_start_month: int = 4
+    summer_start_day: int = 8
+    summer_end_month: int = 11
+    summer_end_day: int = 11
+
+
+@dataclass
+class DaemonConfig:
+    """Daemon runtime configuration."""
+
+    interval_minutes: int = 5
+    lookback_hours: int = 1
+
+
+@dataclass
+class Config:
+    """Main configuration container."""
+
+    influxdb: InfluxDBConfig = field(default_factory=InfluxDBConfig)
+    notification: NotificationConfig = field(default_factory=NotificationConfig)
+    season: SeasonConfig = field(default_factory=SeasonConfig)
+    daemon: DaemonConfig = field(default_factory=DaemonConfig)
+
+
+def get_config_dir() -> Path:
+    """Get the XDG-compliant configuration directory."""
+    return Path(platformdirs.user_config_dir(APP_NAME, APP_AUTHOR))
+
+
+def get_config_path() -> Path:
+    """Get the path to the configuration file."""
+    return get_config_dir() / "config.yaml"
+
+
+def get_state_dir() -> Path:
+    """Get the XDG-compliant state directory for runtime state."""
+    return Path(platformdirs.user_state_dir(APP_NAME, APP_AUTHOR))
+
+
+def get_state_path() -> Path:
+    """Get the path to the state file."""
+    return get_state_dir() / "state.yaml"
+
+
+def ensure_config_dir() -> Path:
+    """Ensure the configuration directory exists."""
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def ensure_state_dir() -> Path:
+    """Ensure the state directory exists."""
+    state_dir = get_state_dir()
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return state_dir
+
+
+def _dict_to_influxdb_config(data: dict[str, Any]) -> InfluxDBConfig:
+    """Convert a dictionary to InfluxDBConfig."""
+    config = InfluxDBConfig()
+    if data:
+        for key in [
+            "url",
+            "token",
+            "org",
+            "bucket",
+            "measurement",
+            "temperature_field",
+            "domain_tag",
+            "location_tag",
+            "mac_tag",
+            "indoor_domain",
+            "outdoor_domain",
+        ]:
+            if key in data:
+                setattr(config, key, data[key])
+    return config
+
+
+def _dict_to_notification_config(data: dict[str, Any]) -> NotificationConfig:
+    """Convert a dictionary to NotificationConfig."""
+    config = NotificationConfig()
+    if data:
+        for key in ["ntfy_topic", "ntfy_server"]:
+            if key in data:
+                setattr(config, key, data[key])
+    return config
+
+
+def _dict_to_season_config(data: dict[str, Any]) -> SeasonConfig:
+    """Convert a dictionary to SeasonConfig."""
+    config = SeasonConfig()
+    if data:
+        for key in [
+            "summer_start_month",
+            "summer_start_day",
+            "summer_end_month",
+            "summer_end_day",
+        ]:
+            if key in data:
+                setattr(config, key, data[key])
+    return config
+
+
+def _dict_to_daemon_config(data: dict[str, Any]) -> DaemonConfig:
+    """Convert a dictionary to DaemonConfig."""
+    config = DaemonConfig()
+    if data:
+        for key in ["interval_minutes", "lookback_hours"]:
+            if key in data:
+                setattr(config, key, data[key])
+    return config
+
+
+def load_config(config_path: Path | None = None) -> Config:
+    """Load configuration from a YAML file.
+
+    Args:
+        config_path: Path to the configuration file. If None, uses the default XDG path.
+
+    Returns:
+        Config object with loaded settings, falling back to defaults for missing values.
+    """
+    if config_path is None:
+        config_path = get_config_path()
+
+    config = Config()
+
+    if not config_path.exists():
+        logger.warning(f"Configuration file not found at {config_path}, using defaults")
+        return config
+
+    try:
+        with open(config_path, "r") as f:
+            data = yaml.safe_load(f) or {}
+    except yaml.YAMLError as e:
+        logger.error(f"Error parsing configuration file: {e}")
+        raise
+
+    config.influxdb = _dict_to_influxdb_config(data.get("influxdb", {}))
+    config.notification = _dict_to_notification_config(data.get("notification", {}))
+    config.season = _dict_to_season_config(data.get("season", {}))
+    config.daemon = _dict_to_daemon_config(data.get("daemon", {}))
+
+    # Allow environment variable override for sensitive data
+    if os.environ.get("INFLUXDB_TOKEN"):
+        config.influxdb.token = os.environ["INFLUXDB_TOKEN"]
+
+    return config
+
+
+def save_default_config(config_path: Path | None = None) -> Path:
+    """Save a default configuration file.
+
+    Args:
+        config_path: Path to save the configuration file. If None, uses the default XDG path.
+
+    Returns:
+        Path to the saved configuration file.
+    """
+    if config_path is None:
+        ensure_config_dir()
+        config_path = get_config_path()
+
+    default_config = {
+        "influxdb": {
+            "url": "https://influxdb.example.com",
+            "token": "your-influxdb-token-here",
+            "org": "my-org",
+            "bucket": "home",
+            "measurement": "environment",
+            "temperature_field": "temperature",
+            "domain_tag": "domain",
+            "location_tag": "location",
+            "mac_tag": "mac",
+            "indoor_domain": "indoors",
+            "outdoor_domain": "outdoors",
+        },
+        "notification": {
+            "ntfy_topic": "your-ntfy-topic-here",
+            "ntfy_server": "https://ntfy.sh",
+        },
+        "season": {
+            "summer_start_month": 4,
+            "summer_start_day": 8,
+            "summer_end_month": 11,
+            "summer_end_day": 11,
+        },
+        "daemon": {
+            "interval_minutes": 5,
+            "lookback_hours": 1,
+        },
+    }
+
+    with open(config_path, "w") as f:
+        yaml.dump(default_config, f, default_flow_style=False, sort_keys=False)
+
+    logger.info(f"Default configuration saved to {config_path}")
+    return config_path