dripfetch 0.1.0__py3-none-any.whl

dripfetch/box/types/weather.py

@@ -0,0 +1,181 @@
+import json
+import threading
+import time
+import urllib.parse
+import urllib.request
+from datetime import datetime
+
+from ..base import BaseBox
+
+
+class WeatherBox(BaseBox):
+    WIDTH = 40
+    HEIGHT = 7
+    CACHE_TIME = 1800
+    TIMEOUT = 10
+
+    CODES = {
+        0: "Clear", 1: "Mostly Clear", 2: "Partly Cloudy", 3: "Cloudy",
+        45: "Fog", 48: "Fog", 51: "Drizzle", 53: "Drizzle", 55: "Heavy Drizzle",
+        56: "Freezing Drizzle", 57: "Freezing Drizzle", 61: "Light Rain",
+        63: "Rain", 65: "Heavy Rain", 66: "Freezing Rain", 67: "Heavy Rain",
+        71: "Light Snow", 73: "Snow", 75: "Heavy Snow", 77: "Snow Grains",
+        80: "Light Showers", 81: "Showers", 82: "Heavy Showers",
+        85: "Snow Showers", 86: "Heavy Snow", 95: "Thunderstorm",
+        96: "Thunderstorm", 99: "Thunderstorm",
+    }
+
+    def __init__(self, stdscr, config, boxes, colors, renderer=None):
+        super().__init__(stdscr, config, boxes, colors, renderer)
+        self.location = config.get("location", "")
+        self.latitude = config.get("latitude")
+        self.longitude = config.get("longitude")
+        self.location_name = self.location
+        self.days = []
+        self.error = None
+        self.loading = True
+        self.last_attempt = 0
+        self.last_update = 0
+        self._thread = None
+        self._lock = threading.Lock()
+        self._start_fetch()
+
+    def _start_fetch(self):
+        now = time.monotonic()
+        if self._thread and self._thread.is_alive():
+            return
+        if now - self.last_attempt < self.CACHE_TIME:
+            return
+        self.last_attempt = now
+        self.loading = True
+        self._thread = threading.Thread(target=self._fetch, daemon=True)
+        self._thread.start()
+
+    def _geocode(self):
+        if self.latitude is not None and self.longitude is not None:
+            return float(self.latitude), float(self.longitude), self.location
+        if not self.location:
+            raise ValueError("No location configured")
+
+        query = urllib.parse.urlencode({
+            "name": self.location,
+            "count": 1,
+            "language": "en",
+            "format": "json",
+        })
+
+        with urllib.request.urlopen(
+            f"https://geocoding-api.open-meteo.com/v1/search?{query}",
+            timeout=self.TIMEOUT,
+        ) as response:
+            results = json.load(response).get("results", [])
+
+        if not results:
+            raise ValueError(f"Location not found: {self.location}")
+
+        result = results[0]
+        name = result.get("name", self.location)
+        country = result.get("country", "")
+        return result["latitude"], result["longitude"], f"{name}, {country}".strip(", ")
+
+    def _fetch(self):
+        try:
+            latitude, longitude, location = self._geocode()
+            params = urllib.parse.urlencode({
+                "latitude": latitude,
+                "longitude": longitude,
+                "daily": "weather_code,temperature_2m_max,temperature_2m_min,precipitation_probability_max",
+                "timezone": "auto",
+                "forecast_days": 5,
+            })
+
+            with urllib.request.urlopen(
+                f"https://api.open-meteo.com/v1/forecast?{params}",
+                timeout=self.TIMEOUT,
+            ) as response:
+                daily = json.load(response)["daily"]
+
+            days = []
+            for i, value in enumerate(daily["time"]):
+                date = datetime.fromisoformat(value)
+                days.append({
+                    "day": "Today" if i == 0 else date.strftime("%a"),
+                    "condition": self.CODES.get(daily["weather_code"][i], "Unknown"),
+                    "high": self._value(daily["temperature_2m_max"][i]),
+                    "low": self._value(daily["temperature_2m_min"][i]),
+                    "rain": self._value(daily["precipitation_probability_max"][i]),
+                })
+
+            with self._lock:
+                self.days = days
+                self.location_name = location
+                self.error = None
+                self.loading = False
+                self.last_update = time.monotonic()
+
+        except Exception as exc:
+            with self._lock:
+                self.error = str(exc)
+                self.loading = False
+
+    @staticmethod
+    def _value(value):
+        return "--" if value is None else str(round(value))
+
+    def update(self):
+        if time.monotonic() - self.last_update >= self.CACHE_TIME:
+            self._start_fetch()
+
+    def _format(self, day):
+        condition = day["condition"][:14]
+        return f"{day['day']:<6} {condition:<14} {day['high']:>2}°/{day['low']:<2}° {day['rain']:>3}%"
+
+    def draw_content(self, x, y, width, height):
+        if width <= 0 or height <= 0:
+            return
+
+        with self._lock:
+            days = list(self.days)
+            loading = self.loading
+            location = self.location_name
+
+        if not days:
+            text = "Fetching weather..." if loading else "Weather unavailable"
+            self.renderer.draw(x, y, text[:width], self.colors.body)
+            return
+
+        self.renderer.draw(
+            x, y,
+            f"WEATHER / {location.upper()}"[:width],
+            self.colors.title,
+        )
+
+        if height < 2:
+            return
+
+        self.renderer.draw(
+            x, y + 1,
+            "─" * min(width, self.WIDTH),
+            self.colors.line,
+        )
+
+        if height < 3:
+            return
+
+        self.renderer.draw(
+            x, y + 2,
+            f"{'DAY':<6} {'CONDITION':<14} {'TEMP':>5} {'RAIN':>4}"[:width],
+            self.colors.line,
+        )
+
+        for row, day in enumerate(days[:5], 3):
+            if row >= height:
+                break
+            self.renderer.draw(
+                x, y + row,
+                self._format(day)[:width],
+                self.colors.body,
+            )
+
+    def dimensions(self):
+        return self.WIDTH, self.HEIGHT

dripfetch/cli.py

@@ -0,0 +1,58 @@
+import argparse
+import curses
+
+from . import __version__
+from .app import App
+from .config import (
+    CONFIG_PATH,
+    create_default_config,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="dripfetch",
+        description=(
+            "A customizable terminal system information display with animated rain."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""controls:
+  q              quit
+  space          pause/resume rain
+  mouse          select box
+  w/a/s/d        move selected box
+  esc            deselect selected box
+configuration:
+  --init-config  restore the default configuration
+  --config-path  show the configuration file currently in use
+  -c PATH        use a custom configuration file""",
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=__version__,
+    )
+    parser.add_argument(
+        "--init-config",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--config-path",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        metavar="PATH",
+    )
+    args = parser.parse_args()
+    if args.init_config:
+        create_default_config(force=True)
+        print(CONFIG_PATH)
+        return
+    config_path = args.config or CONFIG_PATH
+    if args.config_path:
+        print(config_path)
+        return
+    curses.wrapper(App(config_path).run)

dripfetch/config.py

@@ -0,0 +1,405 @@
+import os
+import re
+import tempfile
+from importlib.resources import files
+from pathlib import Path
+
+from ruamel.yaml import YAML
+from ruamel.yaml.error import YAMLError
+
+CONFIG_DIR = Path.home() / ".config" / "dripfetch"
+CONFIG_PATH = CONFIG_DIR / "config.yaml"
+COLOR_RE = re.compile(r"^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$")
+BOX_TYPES = {"text", "clock", "sysinfo", "logo", "weather"}
+BORDER_TYPES = {"single", "double"}
+CLOCK_STYLES = {"single", "double"}
+CLOCK_SIZES = {"medium", "big"}
+DEFAULT_BACKGROUND = "#000000FF"
+
+
+class ConfigError(ValueError):
+    pass
+
+
+def _yaml():
+    yaml = YAML()
+    yaml.preserve_quotes = True
+    yaml.default_flow_style = False
+    yaml.indent(mapping=2, sequence=4, offset=2)
+    return yaml
+
+
+def _error(path, message):
+    raise ConfigError(f"{path}: {message}")
+
+
+def _mapping(value, path):
+    if not isinstance(value, dict):
+        _error(path, "must be a mapping")
+    return value
+
+
+def _string(value, path):
+    if not isinstance(value, str):
+        _error(path, "must be a string")
+    return value
+
+
+def _bool(value, path):
+    if not isinstance(value, bool):
+        _error(path, "must be true or false")
+    return value
+
+
+def _number(value, path):
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        _error(path, "must be a number")
+    return value
+
+
+def _integer(value, path):
+    if isinstance(value, bool) or not isinstance(value, int):
+        _error(path, "must be an integer")
+    return value
+
+
+def _color(value, path):
+    _string(value, path)
+    if not COLOR_RE.fullmatch(value):
+        _error(path, "must be #RRGGBB or #RRGGBBAA")
+
+
+def _enum(value, path, choices):
+    _string(value, path)
+    if value not in choices:
+        _error(path, f"must be one of: {', '.join(sorted(choices))}")
+
+
+def _weighted_list(value, path, value_type):
+    if not isinstance(value, list) or not value:
+        _error(path, "must be a non-empty list")
+    total = 0
+    for index, item in enumerate(value):
+        item_path = f"{path}[{index}]"
+        if not isinstance(item, (list, tuple)) or len(item) != 2:
+            _error(item_path, "must contain exactly two values")
+        weight, item_value = item
+        _number(weight, f"{item_path}[0]")
+        if weight <= 0:
+            _error(f"{item_path}[0]", "must be greater than 0")
+        total += weight
+        if value_type == "color":
+            _color(item_value, f"{item_path}[1]")
+        elif value_type == "integer":
+            _integer(item_value, f"{item_path}[1]")
+        else:
+            _number(item_value, f"{item_path}[1]")
+    if abs(total - 1) > 0.001:
+        _error(path, "weights must sum to 1")
+
+
+def _position(value, path):
+    value = _mapping(value, path)
+    for key in ("horizontal", "vertical"):
+        if key in value:
+            _integer(value[key], f"{path}.{key}")
+
+
+def _validate_text(item, path):
+    if "text" in item:
+        _string(item["text"], f"{path}.text")
+
+
+def _validate_clock(item, path):
+    for key, choices in (
+        ("clock_style", CLOCK_STYLES),
+        ("clock_size", CLOCK_SIZES),
+    ):
+        if key in item:
+            _enum(item[key], f"{path}.{key}", choices)
+    for key in (
+        "clock_24h",
+        "show_seconds",
+        "show_am_pm",
+        "blink_colon",
+        "show_date",
+    ):
+        if key in item:
+            _bool(item[key], f"{path}.{key}")
+
+
+def _validate_sysinfo(item, path):
+    if "colors" not in item:
+        return
+    colors = _mapping(item["colors"], f"{path}.colors")
+    for key in ("text", "title", "line"):
+        if key in colors:
+            _color(colors[key], f"{path}.colors.{key}")
+
+
+def _validate_logo(item, path):
+    if "logo" in item:
+        logo = _string(item["logo"], f"{path}.logo")
+        if not logo:
+            _error(f"{path}.logo", "must not be empty")
+    if "colors" in item:
+        colors = item["colors"]
+        if not isinstance(colors, list) or not colors:
+            _error(f"{path}.colors", "must be a non-empty list")
+        for index, color in enumerate(colors):
+            _color(color, f"{path}.colors[{index}]")
+
+
+def _validate_box(item, index):
+    path = f"boxes.items[{index}]"
+    item = _mapping(item, path)
+    box_type = item.get("type", "text")
+    _enum(box_type, f"{path}.type", BOX_TYPES)
+    if "border" in item:
+        _enum(item["border"], f"{path}.border", BORDER_TYPES)
+    if "position" in item:
+        _position(item["position"], f"{path}.position")
+    validators = {
+        "text": _validate_text,
+        "clock": _validate_clock,
+        "sysinfo": _validate_sysinfo,
+        "logo": _validate_logo,
+        "weather": _validate_weather,
+    }
+    validators[box_type](item, path)
+
+
+def validate_config(config):
+    config = _mapping(config, "config")
+    if "background" in config:
+        _color(config["background"], "background")
+
+    rain = _mapping(config.get("rain", {}), "rain")
+    if "collision" in rain:
+        _bool(rain["collision"], "rain.collision")
+
+    if "intensity" in rain:
+        intensity = _integer(rain["intensity"], "rain.intensity")
+        if intensity < 0:
+            _error(
+                "rain.intensity",
+                "must be greater than or equal to 0",
+            )
+
+    if "character" in rain:
+        character = _string(
+            rain["character"],
+            "rain.character",
+        )
+        if not character:
+            _error(
+                "rain.character",
+                "must not be empty",
+            )
+
+    for key, value_type in (
+        ("colors", "color"),
+        ("speeds", "integer"),
+        ("lengths", "integer"),
+    ):
+        if key in rain:
+            _weighted_list(
+                rain[key],
+                f"rain.{key}",
+                value_type,
+            )
+
+    boxes = _mapping(
+        config.get("boxes", {}),
+        "boxes",
+    )
+
+    if "border" in boxes:
+        _enum(
+            boxes["border"],
+            "boxes.border",
+            BORDER_TYPES,
+        )
+
+    for key in (
+        "border_color",
+        "text_color",
+        "accent_color",
+    ):
+        if key in boxes:
+            _color(
+                boxes[key],
+                f"boxes.{key}",
+            )
+
+    if "padding" in boxes:
+        padding = _mapping(
+            boxes["padding"],
+            "boxes.padding",
+        )
+        for key in (
+            "horizontal",
+            "vertical",
+        ):
+            if key in padding:
+                value = _integer(
+                    padding[key],
+                    f"boxes.padding.{key}",
+                )
+                if value < 0:
+                    _error(
+                        f"boxes.padding.{key}",
+                        "must be greater than or equal to 0",
+                    )
+
+    items = boxes.get("items", [])
+    if not isinstance(items, list):
+        _error(
+            "boxes.items",
+            "must be a list",
+        )
+
+    for index, item in enumerate(items):
+        _validate_box(item, index)
+
+    return config
+
+def _validate_weather(item, path):
+    if "location" in item:
+        location = _string(item["location"], f"{path}.location")
+        if not location:
+            _error(f"{path}.location", "must not be empty")
+
+    if "latitude" in item:
+        latitude = item["latitude"]
+        if not isinstance(latitude, (int, float)):
+            _error(f"{path}.latitude", "must be a number")
+        elif not -90 <= latitude <= 90:
+            _error(f"{path}.latitude", "must be between -90 and 90")
+
+    if "longitude" in item:
+        longitude = item["longitude"]
+        if not isinstance(longitude, (int, float)):
+            _error(f"{path}.longitude", "must be a number")
+        elif not -180 <= longitude <= 180:
+            _error(f"{path}.longitude", "must be between -180 and 180")
+
+    if "location" not in item and not (
+        "latitude" in item and "longitude" in item
+    ):
+        _error(path, "requires location or latitude and longitude")
+
+def _parse(text, path):
+    try:
+        config = _yaml().load(text)
+    except YAMLError as exc:
+        raise ConfigError(f"{path}: invalid YAML: {exc}") from exc
+
+    if config is None:
+        raise ConfigError(f"{path}: configuration is empty")
+
+    return validate_config(config)
+
+
+def _default_config():
+    return files("dripfetch").joinpath(
+        "default_config.yaml",
+    ).read_text(encoding="utf-8")
+
+
+def save_config(config, path=CONFIG_PATH):
+    path = Path(path).expanduser()
+    validate_config(config)
+
+    path.parent.mkdir(
+        parents=True,
+        exist_ok=True,
+    )
+
+    mode = path.stat().st_mode if path.exists() else 0o644
+    temporary = None
+
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            dir=path.parent,
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            delete=False,
+        ) as file:
+            temporary = Path(file.name)
+
+            os.chmod(
+                temporary,
+                mode & 0o777,
+            )
+
+            _yaml().dump(
+                config,
+                file,
+            )
+
+            file.flush()
+            os.fsync(file.fileno())
+
+        os.replace(
+            temporary,
+            path,
+        )
+
+        try:
+            directory = os.open(
+                path.parent,
+                os.O_RDONLY,
+            )
+            try:
+                os.fsync(directory)
+            finally:
+                os.close(directory)
+        except OSError:
+            pass
+
+    finally:
+        if temporary:
+            temporary.unlink(missing_ok=True)
+
+
+def create_default_config(force=False):
+    if CONFIG_PATH.exists() and not force:
+        return False
+
+    save_config(
+        _parse(
+            _default_config(),
+            "default_config.yaml",
+        ),
+        CONFIG_PATH,
+    )
+
+    return True
+
+
+def load_config(path=None):
+    path = Path(path or CONFIG_PATH).expanduser()
+
+    if not path.exists():
+        if path != CONFIG_PATH:
+            raise FileNotFoundError(
+                f"Configuration file not found: {path}",
+            )
+        create_default_config()
+
+    try:
+        text = path.read_text(
+            encoding="utf-8",
+        )
+    except OSError as exc:
+        raise ConfigError(
+            f"{path}: cannot read configuration: {exc}",
+        ) from exc
+
+    return _parse(
+        text,
+        path,
+    )