nocturne-shift 0.5.5__py3-none-any.whl

nocturne_shift/__init__.py

@@ -0,0 +1,2 @@
+from .cli import main
+from .data_store import DataStore

nocturne_shift/bin/get_sunrise_sunset.py

@@ -0,0 +1,241 @@
+#!/usr/bin/python
+
+import re
+import gi
+import sys
+import pprint
+import json
+import argparse
+import subprocess
+import requests
+
+from collections import namedtuple
+from typing import Any
+from .settings import Settings
+from datetime import datetime
+
+gi.require_version("Gio", "2.0")
+from gi.repository import GLib
+
+NOAA = "https://api.sunrise-sunset.org/v2"
+
+
+class GetTimeOfSunriseSunset:
+    def __init__(
+        self,
+        verbose: int = 0,
+        override: bool = False,
+        use_geoclue: bool | None = False,
+        settings: Settings | None = None,
+    ):
+        self.override = override
+        self.verbose = verbose
+        self.use_geoclue = use_geoclue
+        self.settings = settings
+        self.agent = None
+        self.times: tuple[str, str] | None = None
+
+        # Determine Time of sunrise/sunset
+        coords: tuple[float, float] | None = self.determine_location()
+
+        if coords:
+            self.times = self._get_sunrise_sunset(*coords, self.verbose)
+
+    # pass coords from cli to module
+    def __call__(self, coords, verbose=0):
+        return self._get_sunrise_sunset(*coords, verbose)
+
+    def determine_location(self) -> tuple[float, float] | None:
+        if self.use_geoclue is None and self.settings is not None:
+            self.use_geoclue = self.settings.get("use-geoclue")
+
+        # Determine Location
+        if self.use_geoclue is True:
+            coords = self._get_location()
+        else:
+            coords = self._get_static_location_from_settings()
+
+        return coords
+
+    def _get_location(self) -> tuple[float, float]:
+        try:
+
+            # Get location data from Geoclue
+            if self.agent is None:
+                self.agent = subprocess.Popen(
+                    ["/usr/lib/geoclue-2.0/demos/agent"],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+
+            geoclue_data = subprocess.Popen(
+                [
+                    "/usr/lib/geoclue-2.0/demos/where-am-i",
+                    "--accuracy-level=8",
+                    "--time-threshold=3",
+                ],  # `run /usr/lib/geoclue-2.0/demo/where-am-i -h` for more information about options
+                text=True,
+                stdout=subprocess.PIPE,
+            )
+
+            lat_regex = r"^(Lat.*:).*([\.\-\d+]+)"
+            lng_regex = r"^(Long.*:).*([\.\-\d+]+)"
+
+            # READS response for LAT and LNG
+            Coordinates = namedtuple("Coordinates", ["latitude", "longitude"])
+            found_coords: dict[str, float | None] = {
+                "lat": None,
+                "lng": None,
+            }
+
+            for line in iter(geoclue_data.stdout.readline, ""):
+                found_lat = re.match(lat_regex, line)
+                found_lng = re.match(lng_regex, line)
+
+                if found_lat:
+                    matched_string = found_lat.group().split()[1]
+                    found_coords["lat"] = float(matched_string)
+
+                if found_lng:
+                    matched_string = found_lng.group().split()[1]
+                    found_coords["lng"] = float(matched_string)
+
+                # attempt to exit early
+                if found_coords["lat"] and found_coords["lng"]:
+                    break
+
+            geoclue_data.terminate()
+            # raise exception if unable to determine coords
+            if found_coords["lat"] is None and found_coords["lng"] is None:
+                raise TypeError(
+                    "Could not determine location. Please check your geoclue configuration"
+                )
+
+            coords = Coordinates(found_coords["lat"], found_coords["lng"])
+
+            previous_coordinates = None
+            if self.settings is not None:
+                previous_coordinates = self.settings.get(
+                    "last-known-coordinates"
+                )
+                try:
+                    previous_coordinates
+                except Exception as e:
+                    print(f"{e}")
+
+            # CHECK if should save?
+            if self.override or (list(coords) != previous_coordinates):
+                last_known_coordinates = GLib.Variant("(dd)", coords)
+                data: dict = {
+                    "last-known-coordinates": last_known_coordinates,
+                }
+                self._save(data)
+            return coords
+
+        except subprocess.TimeoutExpired as e:
+            print(f"TimeoutExpired: {e.timeout} seconds\n\n {e.stdout}")
+            return None
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error: {e.returncode} \n\n {e.stderr}")
+            return None
+
+        finally:
+            try:
+                if self.agent is not None:
+                    self.agent.kill()  # Gracefully exits
+                    self.agent.wait()  # Prevents zombie processes
+                    self.agent = None
+
+            except Exception as e:
+                print(f"Error: ___{e}")
+
+    def _get_sunrise_sunset(
+        self, lat: float, lng: float, verbose: int
+    ) -> tuple[float, float]:
+        try:
+            params = {"lat": lat, "lng": lng}
+
+            # Handle response
+            response = requests.get(NOAA, params)
+            response.raise_for_status()
+
+            response_data = response.json()
+
+            if self.verbose > 1:
+                json_string = json.dumps(
+                    response_data, indent=4, sort_keys=True
+                )
+                print(f"[nocturne-shift] {json_string}")
+
+            tzid = response_data["tzid"]
+            sunrise = datetime.fromisoformat(
+                response_data["sunrise"]
+            ).strftime("%H:%M")
+            sunset = datetime.fromisoformat(response_data["sunset"]).strftime(
+                "%H:%M"
+            )
+
+            times = (sunrise, sunset)
+
+            saved: dict[str, Any] = {}
+
+            times_tuple = GLib.Variant("(ss)", times)
+            saved = {
+                "timestamp": f"{datetime.now().astimezone().isoformat()}",
+                "tzid": tzid,
+                "times": times_tuple,
+            }
+
+            self._save(saved)
+
+            return times
+
+        except requests.exceptions.HTTPError as http_err:
+            print(f"HTTP error occurred (e.g., 404, 500): {http_err}")
+        except (
+            Exception
+        ) as e:  # Generic Exception must go last becuase it will catch any exception
+            print(f" Generic: {e}")
+
+    def _save(self, data) -> None:
+        if self.settings is None:
+            print(
+                f"nocturne-shift: unable to save {', '.join(data)}: settings unavailable",
+                file=sys.stderr,
+            )
+            return
+
+        try:
+            # DataStore.set picks the right Gio setter for each type
+            for key, value in data.items():
+                self.settings.set(key, value)
+
+            if self.verbose > 0:
+                pprint.pprint(data)
+
+        except Exception as e:
+            print(f"ERROR SAVING: {e}", file=sys.stderr)
+
+    def _get_static_location_from_settings(self) -> tuple[float, float]:
+
+        if self.settings is None:
+            print(
+                "nocturne-shift: no static location: self.settings unavailable",
+                file=sys.stderr,
+            )
+            return None
+
+        lat = self.settings.get("static-latitude")
+        lng = self.settings.get("static-longitude")
+
+        if lat and lng:
+            static_location = (float(lat), float(lng))
+
+            last_known_coordinates = GLib.Variant("(dd)", static_location)
+            self._save({"last-known-coordinates": last_known_coordinates})
+
+            return static_location
+
+        else:
+            print("Missing required keys")

nocturne_shift/bin/is_day_or_night.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python
+
+import sys
+
+from .settings import Settings
+from datetime import datetime
+
+
+def is_day_or_night(
+    times: tuple[str, str] | None = None,
+    settings: Settings | None = None,
+    verbose=0,
+):
+    """Work out "day" or "night" and save it.
+
+    `times` is a (sunrise, sunset) pair of "HH:MM" strings. When it's not
+    given, the times saved in settings are used.
+
+    `settings` is a `Settings`. When it's not given, raise an Error to the caller;
+    """
+
+    settings = settings
+
+    if times is None:
+        if settings is None:
+            raise AttributeError(
+                "nocturne-shift: unable to check `day or night`. settings is None"
+            )
+            return
+
+        times = settings.get("times")
+
+    if not times:
+        return
+    [sunrise, sunset] = times
+    current_time = datetime.now().strftime("%H:%M")  # 24hr format
+
+    # check if currrent time is after sunrise or sunset
+    DAY_NIGHT: str
+
+    if verbose >= 1:
+        print(sunrise, current_time, sunset)
+
+    if sunrise <= current_time < sunset:
+        DAY_NIGHT = "day"
+    else:
+        DAY_NIGHT = "night"
+
+    # set day-or-night
+    try:
+        settings.set("day-or-night", DAY_NIGHT)
+    except Exception as e:
+        print(
+            "nocturne-shift: unable to save day-or-night: settings unavailable",
+            file=sys.stderr,
+        )
+
+    print(f"{DAY_NIGHT}")
+    return DAY_NIGHT

nocturne_shift/bin/settings.py

@@ -0,0 +1,53 @@
+import os
+from pathlib import Path
+from gi.repository import Gio
+from ..data_store import DataStore
+
+DEFAULT_SCHEMA_PATH = os.path.expanduser(
+    Path.home()
+    / ".local"
+    / "share"
+    / "gnome-shell"
+    / "extensions"
+    / "night-shift@christophermca.github.io"
+    / "schemas"
+)
+
+
+class Settings:
+    """Wraps the extension's Gio.Settings.
+
+    `Settings()` returns the Gio.Settings object, or None when the schema
+    isn't installed (for example the GNOME extension is missing). Callers
+    must handle None; nocturne-shift keeps working, it just can't save.
+    """
+
+    def __init__(self, data_store: DataStore | None = None):
+
+        self.data_store = (
+            data_store
+            if data_store is not None
+            else DataStore(DEFAULT_SCHEMA_PATH)
+        )
+
+    @property
+    def data(self):
+        return self.data_store.data
+
+    @property
+    def available(self) -> bool:
+        return self.data_store.available
+
+    @property
+    def get_keys(self) -> list[str]:
+        return self.data_store.get_keys()
+
+    def get(self, key: str):
+        try:
+            return self.data_store.get(key)
+
+        except AttributeError as e:
+            print(f"Error: Failed to GET key:`{key}`")
+
+    def set(self, key, value):
+        self.data_store.set(key, value)

nocturne_shift/cli.py

@@ -0,0 +1,217 @@
+#!/usr/bin/python
+# PYTHON_ARG_COMPLETE_OK
+from .bin.get_sunrise_sunset import GetTimeOfSunriseSunset
+from .bin.is_day_or_night import is_day_or_night
+from .bin.settings import Settings
+from .data_store import DataStore
+
+import sys
+import argparse
+import argcomplete
+import importlib.metadata
+
+PLUGIN_GROUP = "night_shift.commands"
+OPTIONAL_COMMANDS = {"services": "gnome-night-shift"}
+
+try:
+    __version__ = importlib.metadata.version("nocturne-shift")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"
+
+
+def load_commands(subparsers) -> dict:
+    """Let installed plugins add subcommands; returns {command: handler}.
+
+    A plugin registers in its own pyproject.toml:
+        [project.entry-points."night_shift.commands"]
+        services = "night_shift_services.cli:register"
+    `register(subparsers)` adds its parser and returns `handler(args)`.
+    """
+    handlers = {}
+    for entry_point in importlib.metadata.entry_points(group=PLUGIN_GROUP):
+        try:
+            handlers[entry_point.name] = entry_point.load()(subparsers)
+        except (
+            Exception
+        ) as e:  # a broken plugin must not take the core CLI down
+            print(
+                f"nocturne-shift: skipping plugin {entry_point.name!r} ({e})",
+                file=sys.stderr,
+            )
+
+    # Commands whose plugin isn't installed still parse, and say how to get them
+    for name, extra in OPTIONAL_COMMANDS.items():
+        if name not in handlers:
+            stub = subparsers.add_parser(
+                name, help=f"(not installed: pip install '{extra}')"
+            )
+            stub.add_argument(
+                "rest", nargs=argparse.REMAINDER
+            )  # accept anything
+            handlers[name] = _not_installed(name, extra)
+    return handlers
+
+
+def _not_installed(name, extra):
+    def handler(args):
+        sys.exit(f"nocturne-shift {name} requires: pip install '{extra}'")
+
+    return handler
+
+
+def check(times=None, settings=None, verbose=0):
+    try:
+        is_day_or_night(times, settings, verbose)
+    except AttributeError as e:
+        print(f"ERROR: {e}")
+
+
+def run_once(
+    verbose: int = 0,
+    override: bool = False,
+    check_now: bool | str | None = False,
+    use_geoclue: bool | None = False,
+    settings: Settings | None = None,
+):
+    try:
+        sunrise_sunset = GetTimeOfSunriseSunset(
+            verbose, override, use_geoclue, settings
+        )
+        if check_now != False:
+            try:
+                check(sunrise_sunset.times, settings, verbose)
+            except Exception as e:
+                print(f"check failed: {e}")
+    except Exception as e:
+        print(f"ERROR during run_once(): {e} ")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Get the times for the sunrise/sunset",
+        prog="nocturne-shift",
+    )
+
+    sub_parsers = parser.add_subparsers(dest="command")
+    commands = load_commands(sub_parsers)
+
+    parser.add_argument(
+        "--lat",
+        dest="latitude",
+        type=float,
+        nargs="?",
+        help="compares current time with sunrise/sunset time",
+    )
+
+    parser.add_argument(
+        "--lng",
+        dest="longitude",
+        type=float,
+        nargs="?",
+        help="compares current time with sunrise/sunset time",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--check-now",
+        metavar="SCHEMA_PATH",
+        nargs="?",
+        default=False,
+        help="compares current time with sunrise/sunset time",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        dest="override",
+        action="store_true",
+        help="ignores cached data",
+    )
+
+    parser.add_argument(
+        "-g",
+        "--geoclue",
+        dest="use_geoclue",
+        action="store_true",
+        help="use geoclue to determine location",
+    )
+
+    parser.add_argument(
+        "-w",
+        "--watch",
+        nargs="?",
+        default=False,
+        metavar="SCHEMA_PATH",
+        help="watch for changes in data_store",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Prints more information",
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Prints more information",
+    )
+
+    argcomplete.autocomplete(parser)
+    args = parser.parse_args()
+
+    # ------------ Plugin Commands
+    if args.command in commands:
+        return commands[args.command](args)
+
+    # ------------ Watch
+    if args.watch != False:
+        settings = (
+            Settings(DataStore(args.watch)) if args.watch else Settings()
+        )
+
+        # TODO validate using run_once will work here.
+        return run_once(
+            verbose=args.verbose,
+            override=args.override,
+            check_now=False,  # the watch option only gets the current location if location has changed for an OVERRIDE flag was passed
+            use_geoclue=None,  # watch will handle use settings
+            settings=settings,
+        )
+
+    # ------------ Static coordinates
+    elif args.latitude != None and args.longitude != None:
+        # One Settings per run, shared by everything below, so a missing schema is reported once. Only created on paths that need it.
+        settings = Settings()
+        coords = tuple([args.latitude, args.longitude])
+        sunrise_sunset = GetTimeOfSunriseSunset(
+            args.verbose, args.override, settings=settings
+        )
+        times = sunrise_sunset(coords, args.verbose)
+        if args.check_now != False:
+            return check(times, settings, args.verbose)
+
+    # ------------ Using Geoclue
+    elif args.use_geoclue:
+        settings = Settings()
+        return run_once(
+            args.verbose,
+            args.override,
+            args.check_now,
+            args.use_geoclue,
+            settings,
+        )
+
+    elif args.check_now != False:
+        settings = (
+            Settings(DataStore(args.check_now))
+            if type(args.check_now) is str
+            else Settings()
+        )
+
+        check(settings=settings, verbose=args.verbose)
+        return None
+    else:
+        parser.print_help()

nocturne_shift/data_store.py

@@ -0,0 +1,120 @@
+import sys
+import subprocess
+from pathlib import Path
+from gi.repository import Gio, GLib
+from typing import TypedDict, get_type_hints
+
+default_config_file = ".var/night-shift/data.json"
+
+
+def _compile_schema(schema_path, schema_id) -> Gio.SettingsSchema | None:
+    try:
+        schema_source = Gio.SettingsSchemaSource.new_from_directory(
+            schema_path, Gio.SettingsSchemaSource.get_default(), False
+        )
+        schema = schema_source.lookup(schema_id, True)
+        if schema is None:
+            raise LookupError(f"schema {schema_id} not found")
+
+        return schema
+
+    except Exception as e:
+        print(
+            f"nocturne-shift: settings unavailable, nothing will be saved ({e})",
+            file=sys.stderr,
+        )
+
+
+class TypedStore(TypedDict):
+    day_or_night: str
+    last_known_coordinates: tuple[float, float]
+    static_latitude: str
+    static_longitude: str
+    timestamp: str
+    times: tuple[str, str]
+    tzid: str
+    use_geoclue: bool
+
+
+class DataStore:
+
+    def __init__(self, schema_path: str):
+        self.data: GObject | TypedStore | None = None
+        self.schema_path = schema_path
+
+        self.schema: Gio.SettingsSchema | None = None
+
+        try:
+            schema_xml = next(
+                Path(self.schema_path).glob("*.gschema.xml"), None
+            )
+            if schema_xml is None:
+                raise LookupError(f"no .gschema.xml in {self.schema_path}")
+            package_id = schema_xml.name.removesuffix(".gschema.xml")
+            self.schema = _compile_schema(
+                self.schema_path, schema_id=package_id
+            )
+
+            if self.schema is not None:
+                self.data = Gio.Settings.new_full(self.schema, None, None)
+            else:
+                self.data = None
+
+        except Exception as e:
+            print(
+                f"nocturne-shift: settings unavailable, nothing will be saved ({e})",
+                file=sys.stderr,
+            )
+            self.data = None
+
+    def get_keys(self) -> list[str]:
+        if self.schema is None:
+            return []
+        else:
+            return sorted(self.schema.list_keys())
+
+    def get(self, key: str):
+        if self.data is None:
+            return None
+
+        annotations = get_type_hints(TypedStore)
+
+        norm_key = key.replace("-", "_")
+        value = annotations.get(norm_key)()
+
+        match value:
+            case bool():
+                value = self.data[key]
+                return value
+            case str():
+                value = self.data[key]
+                return value
+            case int():
+                value = self.data[key]
+                return value
+            case _:
+                value = self.data[key]
+                return value
+
+    def set(self, key: str, value):
+        if self.data is None:
+            raise AttributeError("`data` is None")
+            return None
+
+        match value:
+            case bool():  # bool must go before int: bool is a subclass of int
+                self.data.set_boolean(key, value)
+            case str():
+                self.data.set_string(key, value)
+            case int():
+                self.data.set_int(key, value)
+            case GLib.Variant():  # tuples like "times" (ss) and coords (dd)
+                self.data.set_value(key, value)
+            case _:
+                raise TypeError(
+                    f"can't save {key}: unsupported type {type(value).__name__}"
+                )
+
+    @property
+    def available(self) -> bool:
+        return self.data is not None