From f663e6f6908a9dfb05ac22e867e726c1bf6f0960 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Wed, 11 Jun 2025 00:41:05 +1000 Subject: internal: refactor for packaging Package using python-build, python-installer and hatch --- src/caelestia/utils/scheme.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/caelestia/utils/scheme.py (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py new file mode 100644 index 0000000..e69de29 -- cgit v1.2.3-freya From dc855e1b01e9b4526927b8bd69daca733afd97c2 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Wed, 11 Jun 2025 17:37:04 +1000 Subject: internal: refactor scheme Also use a single file to store scheme data --- src/caelestia/data.py | 120 ----------------------- src/caelestia/parser.py | 2 +- src/caelestia/subcommands/shell.py | 4 +- src/caelestia/utils/hypr.py | 2 +- src/caelestia/utils/paths.py | 13 +++ src/caelestia/utils/scheme.py | 194 +++++++++++++++++++++++++++++++++++++ 6 files changed, 211 insertions(+), 124 deletions(-) delete mode 100644 src/caelestia/data.py create mode 100644 src/caelestia/utils/paths.py (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/data.py b/src/caelestia/data.py deleted file mode 100644 index fa97a03..0000000 --- a/src/caelestia/data.py +++ /dev/null @@ -1,120 +0,0 @@ -import os -from pathlib import Path - -config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) -data_dir = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local/share")) -state_dir = Path(os.getenv("XDG_STATE_HOME", Path.home() / ".local/state")) - -c_config_dir = config_dir / "caelestia" -c_data_dir = data_dir / "caelestia" -c_state_dir = state_dir / "caelestia" - -scheme_name_path = c_state_dir / "scheme/name.txt" -scheme_flavour_path = c_state_dir / "scheme/flavour.txt" -scheme_colours_path = c_state_dir / "scheme/colours.txt" -scheme_mode_path = c_state_dir / "scheme/mode.txt" -scheme_variant_path = c_state_dir / "scheme/variant.txt" - -scheme_data_path = Path(__file__).parent / "data/schemes" - -scheme_variants = [ - "tonalspot", - "vibrant", - "expressive", - "fidelity", - "fruitsalad", - "monochrome", - "neutral", - "rainbow", - "content", -] - -scheme_names: list[str] = None -scheme_flavours: list[str] = None -scheme_modes: list[str] = None - -scheme_name: str = None -scheme_flavour: str = None -scheme_colours: dict[str, str] = None -scheme_mode: str = None -scheme_variant: str = None - - -def get_scheme_path() -> Path: - return (scheme_data_path / get_scheme_name() / get_scheme_flavour() / get_scheme_mode()).with_suffix(".txt") - - -def get_scheme_names() -> list[str]: - global scheme_names - - if scheme_names is None: - scheme_names = [f.name for f in scheme_data_path.iterdir() if f.is_dir()] - - return scheme_names - - -def get_scheme_flavours() -> list[str]: - global scheme_flavours - - if scheme_flavours is None: - scheme_flavours = [f.name for f in (scheme_data_path / get_scheme_name()).iterdir() if f.is_dir()] - - return scheme_flavours - - -def get_scheme_modes() -> list[str]: - global scheme_modes - - if scheme_modes is None: - scheme_modes = [ - f.stem for f in (scheme_data_path / get_scheme_name() / get_scheme_flavour()).iterdir() if f.is_file() - ] - - return scheme_modes - - -def get_scheme_name() -> str: - global scheme_name - - if scheme_name is None: - scheme_name = scheme_name_path.read_text().strip() if scheme_name_path.exists() else "catppuccin" - - return scheme_name - - -def get_scheme_flavour() -> str: - global scheme_flavour - - if scheme_flavour is None: - scheme_flavour = scheme_flavour_path.read_text().strip() if scheme_flavour_path.exists() else "mocha" - - return scheme_flavour - - -def get_scheme_colours() -> dict[str, str]: - global scheme_colours - - if scheme_colours is None: - scheme_colours = { - k.strip(): v.strip() for k, v in (line.split(" ") for line in get_scheme_path().read_text().splitlines()) - } - - return scheme_colours - - -def get_scheme_mode() -> str: - global scheme_mode - - if scheme_mode is None: - scheme_mode = scheme_mode_path.read_text().strip() if scheme_mode_path.exists() else "dark" - - return scheme_mode - - -def get_scheme_variant() -> str: - global scheme_variant - - if scheme_variant is None: - scheme_variant = scheme_variant_path.read_text().strip() if scheme_variant_path.exists() else "tonalspot" - - return scheme_variant diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py index 00556b0..eb8734e 100644 --- a/src/caelestia/parser.py +++ b/src/caelestia/parser.py @@ -1,6 +1,5 @@ import argparse -from caelestia.data import get_scheme_names, scheme_variants from caelestia.subcommands import ( clipboard, emoji, @@ -14,6 +13,7 @@ from caelestia.subcommands import ( wallpaper, wsaction, ) +from caelestia.utils.scheme import get_scheme_names, scheme_variants def parse_args() -> (argparse.ArgumentParser, argparse.Namespace): diff --git a/src/caelestia/subcommands/shell.py b/src/caelestia/subcommands/shell.py index 2d8d14e..25a39d8 100644 --- a/src/caelestia/subcommands/shell.py +++ b/src/caelestia/subcommands/shell.py @@ -1,7 +1,7 @@ import subprocess from argparse import Namespace -from caelestia import data +from caelestia.utils import paths class Command: @@ -25,7 +25,7 @@ class Command: self.shell() def shell(self, *args: list[str]) -> str: - return subprocess.check_output(["qs", "-p", data.c_data_dir / "shell", *args], text=True) + return subprocess.check_output(["qs", "-p", paths.c_data_dir / "shell", *args], text=True) def print_ipc(self) -> None: print(self.shell("ipc", "show"), end="") diff --git a/src/caelestia/utils/hypr.py b/src/caelestia/utils/hypr.py index d829f22..621e28e 100644 --- a/src/caelestia/utils/hypr.py +++ b/src/caelestia/utils/hypr.py @@ -5,7 +5,7 @@ import socket socket_path = f"{os.getenv('XDG_RUNTIME_DIR')}/hypr/{os.getenv('HYPRLAND_INSTANCE_SIGNATURE')}/.socket.sock" -def message(msg: str, json: bool = True) -> str or dict[str, any]: +def message(msg: str, json: bool = True) -> str | dict[str, any]: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock: sock.connect(socket_path) diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py new file mode 100644 index 0000000..aff6ea0 --- /dev/null +++ b/src/caelestia/utils/paths.py @@ -0,0 +1,13 @@ +import os +from pathlib import Path + +config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) +data_dir = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local/share")) +state_dir = Path(os.getenv("XDG_STATE_HOME", Path.home() / ".local/state")) + +c_config_dir = config_dir / "caelestia" +c_data_dir = data_dir / "caelestia" +c_state_dir = state_dir / "caelestia" + +scheme_path = c_state_dir / "scheme.json" +scheme_data_path = Path(__file__).parent.parent / "data/schemes" diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index e69de29..79a0c21 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -0,0 +1,194 @@ +import json +from pathlib import Path + +from caelestia.utils.paths import scheme_data_path, scheme_path + + +class Scheme: + _name: str + _flavour: str + _mode: str + _variant: str + _colours: dict[str, str] + + def __init__(self, json: dict[str, any] | None) -> None: + if json is None: + self._name = "catppuccin" + self._flavour = "mocha" + self._mode = "dark" + self._variant = "tonalspot" + self._colours = read_colours_from_file(self.get_colours_path()) + else: + self._name = json["name"] + self._flavour = json["flavour"] + self._mode = json["mode"] + self._variant = json["variant"] + self._colours = json["colours"] + + @property + def name(self) -> str: + return self._name + + @name.setter + def name(self, name: str) -> None: + if name == self._name: + return + + if name not in get_scheme_names(): + raise ValueError(f"Invalid scheme name: {name}") + + self._name = name + self._check_flavour() + self._check_mode() + self._update_colours() + self.save() + + @property + def flavour(self) -> str: + return self._flavour + + @flavour.setter + def flavour(self, flavour: str) -> None: + if flavour == self._flavour: + return + + if flavour not in get_scheme_flavours(): + raise ValueError(f"Invalid scheme flavour: {flavour}") + + self._flavour = flavour + self._check_mode() + self._update_colours() + self.save() + + @property + def mode(self) -> str: + return self._mode + + @mode.setter + def mode(self, mode: str) -> None: + if mode == self._mode: + return + + if mode not in get_scheme_modes(): + raise ValueError(f"Invalid scheme mode: {mode}") + + self._mode = mode + self._update_colours() + self.save() + + @property + def variant(self) -> str: + return self._variant + + @variant.setter + def variant(self, variant: str) -> None: + self._variant = variant + + @property + def colours(self) -> dict[str, str]: + return self._colours + + def get_colours_path(self) -> Path: + return (scheme_data_path / self.name / self.flavour / self.mode).with_suffix(".txt") + + def save(self) -> None: + scheme_path.parent.mkdir(parents=True, exist_ok=True) + with scheme_path.open("w") as f: + json.dump( + { + "name": self.name, + "flavour": self.flavour, + "mode": self.mode, + "variant": self.variant, + "colours": self.colours, + }, + f, + ) + + def _check_flavour(self) -> None: + global scheme_flavours + scheme_flavours = None + if self._flavour not in get_scheme_flavours(): + self._flavour = get_scheme_flavours()[0] + + def _check_mode(self) -> None: + global scheme_modes + scheme_modes = None + if self._mode not in get_scheme_modes(): + self._mode = get_scheme_modes()[0] + + def _update_colours(self) -> None: + self._colours = read_colours_from_file(self.get_colours_path()) + + +scheme_variants = [ + "tonalspot", + "vibrant", + "expressive", + "fidelity", + "fruitsalad", + "monochrome", + "neutral", + "rainbow", + "content", +] + +scheme_names: list[str] = None +scheme_flavours: list[str] = None +scheme_modes: list[str] = None + +scheme: Scheme = None + + +def read_colours_from_file(path: Path) -> dict[str, str]: + return {k.strip(): v.strip() for k, v in (line.split(" ") for line in path.read_text().splitlines())} + + +def get_scheme_path() -> Path: + return get_scheme().get_colours_path() + + +def get_scheme() -> Scheme: + global scheme + + if scheme is None: + try: + scheme_json = json.loads(scheme_path.read_text()) + scheme = Scheme(scheme_json) + except (IOError, json.JSONDecodeError): + scheme = Scheme(None) + + return scheme + + +def get_scheme_names() -> list[str]: + global scheme_names + + if scheme_names is None: + scheme_names = [f.name for f in scheme_data_path.iterdir() if f.is_dir()] + scheme_names.append("dynamic") + + return scheme_names + + +def get_scheme_flavours() -> list[str]: + global scheme_flavours + + if scheme_flavours is None: + name = get_scheme().name + if name == "dynamic": + scheme_flavours = ["default", "alt1", "alt2"] + else: + scheme_flavours = [f.name for f in (scheme_data_path / name).iterdir() if f.is_dir()] + + return scheme_flavours + + +def get_scheme_modes() -> list[str]: + global scheme_modes + + if scheme_modes is None: + scheme = get_scheme() + scheme_modes = [f.stem for f in (scheme_data_path / scheme.name / scheme.flavour).iterdir() if f.is_file()] + + return scheme_modes -- cgit v1.2.3-freya From f43987ef2f55ede746c5cc37567f5e74ba515fb3 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Wed, 11 Jun 2025 18:07:34 +1000 Subject: feat: impl scheme command (partial) --- src/caelestia/parser.py | 1 - src/caelestia/subcommands/scheme.py | 16 +++++++++++++++- src/caelestia/utils/scheme.py | 3 +++ 3 files changed, 18 insertions(+), 2 deletions(-) (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py index eb8734e..9718938 100644 --- a/src/caelestia/parser.py +++ b/src/caelestia/parser.py @@ -61,7 +61,6 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace): # Create parser for scheme opts scheme_parser = command_parser.add_parser("scheme", help="manage the colour scheme") scheme_parser.set_defaults(cls=scheme.Command) - scheme_parser.add_argument("-g", "--get", action="store_true", help="print the current scheme") scheme_parser.add_argument("-r", "--random", action="store_true", help="switch to a random scheme") scheme_parser.add_argument("-n", "--name", choices=get_scheme_names(), help="the name of the scheme to switch to") scheme_parser.add_argument("-f", "--flavour", help="the flavour to switch to") diff --git a/src/caelestia/subcommands/scheme.py b/src/caelestia/subcommands/scheme.py index 37f9a2b..19e62db 100644 --- a/src/caelestia/subcommands/scheme.py +++ b/src/caelestia/subcommands/scheme.py @@ -1,5 +1,7 @@ from argparse import Namespace +from caelestia.utils.scheme import get_scheme + class Command: args: Namespace @@ -8,4 +10,16 @@ class Command: self.args = args def run(self) -> None: - pass + scheme = get_scheme() + + if self.args.random: + scheme.set_random() + elif self.args.name or self.args.flavour or self.args.mode: + if self.args.name: + scheme.name = self.args.name + if self.args.flavour: + scheme.flavour = self.args.flavour + if self.args.mode: + scheme.mode = self.args.mode + else: + print(scheme) diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index 79a0c21..4b05100 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -120,6 +120,9 @@ class Scheme: def _update_colours(self) -> None: self._colours = read_colours_from_file(self.get_colours_path()) + def __str__(self) -> str: + return f"Scheme(name={self.name}, flavour={self.flavour}, mode={self.mode}, variant={self.variant})" + scheme_variants = [ "tonalspot", -- cgit v1.2.3-freya From 464334136c468fe4ed1b4b96d62cacc71be913b4 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Wed, 11 Jun 2025 21:45:18 +1000 Subject: scheme: better error messages Print valid flavours/modes when invalid flavour/mode is given --- src/caelestia/utils/scheme.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index 4b05100..c26d2f8 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -53,7 +53,7 @@ class Scheme: return if flavour not in get_scheme_flavours(): - raise ValueError(f"Invalid scheme flavour: {flavour}") + raise ValueError(f'Invalid scheme flavour: "{flavour}". Valid flavours: {get_scheme_flavours()}') self._flavour = flavour self._check_mode() @@ -70,7 +70,7 @@ class Scheme: return if mode not in get_scheme_modes(): - raise ValueError(f"Invalid scheme mode: {mode}") + raise ValueError(f'Invalid scheme mode: "{mode}". Valid modes: {get_scheme_modes()}') self._mode = mode self._update_colours() -- cgit v1.2.3-freya From 194826efaa95480bfe1799f889ca5c02571b3e36 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 15:48:02 +1000 Subject: feat: generate dynamic schemes --- src/caelestia/utils/material/__init__.py | 52 ++++++++ src/caelestia/utils/material/generator.py | 192 ++++++++++++++++++++++++++++++ src/caelestia/utils/material/score.py | 129 ++++++++++++++++++++ src/caelestia/utils/paths.py | 19 ++- src/caelestia/utils/scheme.py | 19 ++- src/caelestia/utils/theme.py | 2 +- 6 files changed, 405 insertions(+), 8 deletions(-) create mode 100644 src/caelestia/utils/material/__init__.py create mode 100755 src/caelestia/utils/material/generator.py create mode 100755 src/caelestia/utils/material/score.py (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/utils/material/__init__.py b/src/caelestia/utils/material/__init__.py new file mode 100644 index 0000000..8adab1f --- /dev/null +++ b/src/caelestia/utils/material/__init__.py @@ -0,0 +1,52 @@ +import json +from pathlib import Path + +from materialyoucolor.hct import Hct + +from caelestia.utils.material.generator import gen_scheme +from caelestia.utils.material.score import score +from caelestia.utils.paths import compute_hash, scheme_cache_dir, wallpaper_thumbnail_path + + +def get_score_for_image(image: str, cache_base: Path) -> tuple[list[Hct], list[Hct]]: + cache = cache_base / "score.json" + + try: + with cache.open("r") as f: + return [[Hct.from_int(c) for c in li] for li in json.load(f)] + except (IOError, json.JSONDecodeError): + pass + + s = score(image) + + cache.parent.mkdir(parents=True, exist_ok=True) + with cache.open("w") as f: + json.dump([[c.to_int() for c in li] for li in s], f) + + return s + + +def get_colours_for_image(image: str = str(wallpaper_thumbnail_path), scheme=None) -> dict[str, str]: + if scheme is None: + from caelestia.utils.scheme import get_scheme + + scheme = get_scheme() + + cache_base = scheme_cache_dir / compute_hash(image) + cache = (cache_base / scheme.variant / scheme.flavour / scheme.mode).with_suffix(".json") + + try: + with cache.open("r") as f: + return json.load(f) + except (IOError, json.JSONDecodeError): + pass + + primaries, colours = get_score_for_image(image, cache_base) + i = ["default", "alt1", "alt2"].index(scheme.flavour) + scheme = gen_scheme(scheme, primaries[i], colours) + + cache.parent.mkdir(parents=True, exist_ok=True) + with cache.open("w") as f: + json.dump(scheme, f) + + return scheme diff --git a/src/caelestia/utils/material/generator.py b/src/caelestia/utils/material/generator.py new file mode 100755 index 0000000..33ff0e8 --- /dev/null +++ b/src/caelestia/utils/material/generator.py @@ -0,0 +1,192 @@ +from materialyoucolor.blend import Blend +from materialyoucolor.dynamiccolor.material_dynamic_colors import ( + DynamicScheme, + MaterialDynamicColors, +) +from materialyoucolor.hct import Hct +from materialyoucolor.hct.cam16 import Cam16 +from materialyoucolor.scheme.scheme_content import SchemeContent +from materialyoucolor.scheme.scheme_expressive import SchemeExpressive +from materialyoucolor.scheme.scheme_fidelity import SchemeFidelity +from materialyoucolor.scheme.scheme_fruit_salad import SchemeFruitSalad +from materialyoucolor.scheme.scheme_monochrome import SchemeMonochrome +from materialyoucolor.scheme.scheme_neutral import SchemeNeutral +from materialyoucolor.scheme.scheme_rainbow import SchemeRainbow +from materialyoucolor.scheme.scheme_tonal_spot import SchemeTonalSpot +from materialyoucolor.scheme.scheme_vibrant import SchemeVibrant + + +def hex_to_hct(hex: str) -> Hct: + return Hct.from_int(int(f"0xFF{hex}", 16)) + + +light_colours = [ + hex_to_hct("dc8a78"), + hex_to_hct("dd7878"), + hex_to_hct("ea76cb"), + hex_to_hct("8839ef"), + hex_to_hct("d20f39"), + hex_to_hct("e64553"), + hex_to_hct("fe640b"), + hex_to_hct("df8e1d"), + hex_to_hct("40a02b"), + hex_to_hct("179299"), + hex_to_hct("04a5e5"), + hex_to_hct("209fb5"), + hex_to_hct("1e66f5"), + hex_to_hct("7287fd"), +] + +dark_colours = [ + hex_to_hct("f5e0dc"), + hex_to_hct("f2cdcd"), + hex_to_hct("f5c2e7"), + hex_to_hct("cba6f7"), + hex_to_hct("f38ba8"), + hex_to_hct("eba0ac"), + hex_to_hct("fab387"), + hex_to_hct("f9e2af"), + hex_to_hct("a6e3a1"), + hex_to_hct("94e2d5"), + hex_to_hct("89dceb"), + hex_to_hct("74c7ec"), + hex_to_hct("89b4fa"), + hex_to_hct("b4befe"), +] + +colour_names = [ + "rosewater", + "flamingo", + "pink", + "mauve", + "red", + "maroon", + "peach", + "yellow", + "green", + "teal", + "sky", + "sapphire", + "blue", + "lavender", + "success", + "error", +] + + +def grayscale(colour: Hct, light: bool) -> None: + colour.chroma = 0 + + +def mix(a: Hct, b: Hct, w: float) -> Hct: + return Hct.from_int(Blend.cam16_ucs(a.to_int(), b.to_int(), w)) + + +def harmonize(a: Hct, b: Hct) -> Hct: + return Hct.from_int(Blend.harmonize(a.to_int(), b.to_int())) + + +def lighten(colour: Hct, amount: float) -> Hct: + diff = (100 - colour.tone) * amount + return Hct.from_hct(colour.hue, colour.chroma + diff / 2, colour.tone + diff) + + +def darken(colour: Hct, amount: float) -> Hct: + diff = colour.tone * amount + return Hct.from_hct(colour.hue, colour.chroma + diff / 2, colour.tone - diff) + + +def distance(colour: Cam16, base: Cam16) -> float: + return colour.distance(base) + + +def smart_sort(colours: list[Hct], base: list[Hct]) -> dict[str, Hct]: + sorted_colours = [None] * len(colours) + distances = {} + + cams = [(c, Cam16.from_int(c.to_int())) for c in colours] + base_cams = [Cam16.from_int(c.to_int()) for c in base] + + for colour, cam in cams: + dist = [(i, distance(cam, b)) for i, b in enumerate(base_cams)] + dist.sort(key=lambda x: x[1]) + distances[colour] = dist + + for colour in colours: + while len(distances[colour]) > 0: + i, dist = distances[colour][0] + + if sorted_colours[i] is None: + sorted_colours[i] = colour, dist + break + elif sorted_colours[i][1] > dist: + old = sorted_colours[i][0] + sorted_colours[i] = colour, dist + colour = old + + distances[colour].pop(0) + + return {colour_names[i]: c[0] for i, c in enumerate(sorted_colours)} + + +def get_scheme(scheme: str) -> DynamicScheme: + if scheme == "content": + return SchemeContent + if scheme == "expressive": + return SchemeExpressive + if scheme == "fidelity": + return SchemeFidelity + if scheme == "fruitsalad": + return SchemeFruitSalad + if scheme == "monochrome": + return SchemeMonochrome + if scheme == "neutral": + return SchemeNeutral + if scheme == "rainbow": + return SchemeRainbow + if scheme == "tonalspot": + return SchemeTonalSpot + return SchemeVibrant + + +def gen_scheme(scheme, primary: Hct, colours: list[Hct]) -> dict[str, str]: + light = scheme.mode == "light" + base = light_colours if light else dark_colours + + # Sort colours and turn into dict + colours = smart_sort(colours, base) + + # Harmonize colours + for name, hct in colours.items(): + if scheme.variant == "monochrome": + grayscale(hct, light) + else: + harmonized = harmonize(hct, primary) + colours[name] = darken(harmonized, 0.35) if light else lighten(harmonized, 0.65) + + # Material colours + primary_scheme = get_scheme(scheme.variant)(primary, not light, 0) + for colour in vars(MaterialDynamicColors).keys(): + colour_name = getattr(MaterialDynamicColors, colour) + if hasattr(colour_name, "get_hct"): + colours[colour] = colour_name.get_hct(primary_scheme) + + # FIXME: deprecated stuff + colours["text"] = colours["onBackground"] + colours["subtext1"] = colours["onSurfaceVariant"] + colours["subtext0"] = colours["outline"] + colours["overlay2"] = mix(colours["surface"], colours["outline"], 0.86) + colours["overlay1"] = mix(colours["surface"], colours["outline"], 0.71) + colours["overlay0"] = mix(colours["surface"], colours["outline"], 0.57) + colours["surface2"] = mix(colours["surface"], colours["outline"], 0.43) + colours["surface1"] = mix(colours["surface"], colours["outline"], 0.29) + colours["surface0"] = mix(colours["surface"], colours["outline"], 0.14) + colours["base"] = colours["surface"] + colours["mantle"] = darken(colours["surface"], 0.03) + colours["crust"] = darken(colours["surface"], 0.05) + colours["success"] = harmonize(base[8], primary) + + # For debugging + print("\n".join(["{}: \x1b[48;2;{};{};{}m \x1b[0m".format(n, *c.to_rgba()[:3]) for n, c in colours.items()])) + + return {k: hex(v.to_int())[4:] for k, v in colours.items()} diff --git a/src/caelestia/utils/material/score.py b/src/caelestia/utils/material/score.py new file mode 100755 index 0000000..da8b062 --- /dev/null +++ b/src/caelestia/utils/material/score.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python + +import sys + +from materialyoucolor.dislike.dislike_analyzer import DislikeAnalyzer +from materialyoucolor.hct import Hct +from materialyoucolor.quantize import ImageQuantizeCelebi +from materialyoucolor.utils.math_utils import difference_degrees, sanitize_degrees_int + + +class Score: + TARGET_CHROMA = 48.0 + WEIGHT_PROPORTION = 0.7 + WEIGHT_CHROMA_ABOVE = 0.3 + WEIGHT_CHROMA_BELOW = 0.1 + CUTOFF_CHROMA = 5.0 + CUTOFF_EXCITED_PROPORTION = 0.01 + + def __init__(self): + pass + + @staticmethod + def score(colors_to_population: dict) -> tuple[list[Hct], list[Hct]]: + desired = 14 + filter_enabled = True + dislike_filter = True + + colors_hct = [] + hue_population = [0] * 360 + population_sum = 0 + + for rgb, population in colors_to_population.items(): + hct = Hct.from_int(rgb) + colors_hct.append(hct) + hue = int(hct.hue) + hue_population[hue] += population + population_sum += population + + hue_excited_proportions = [0.0] * 360 + + for hue in range(360): + proportion = hue_population[hue] / population_sum + for i in range(hue - 14, hue + 16): + neighbor_hue = int(sanitize_degrees_int(i)) + hue_excited_proportions[neighbor_hue] += proportion + + # Score colours + scored_hct = [] + for hct in colors_hct: + hue = int(sanitize_degrees_int(round(hct.hue))) + proportion = hue_excited_proportions[hue] + + if filter_enabled and (hct.chroma < Score.CUTOFF_CHROMA or proportion <= Score.CUTOFF_EXCITED_PROPORTION): + continue + + proportion_score = proportion * 100.0 * Score.WEIGHT_PROPORTION + chroma_weight = Score.WEIGHT_CHROMA_BELOW if hct.chroma < Score.TARGET_CHROMA else Score.WEIGHT_CHROMA_ABOVE + chroma_score = (hct.chroma - Score.TARGET_CHROMA) * chroma_weight + score = proportion_score + chroma_score + scored_hct.append({"hct": hct, "score": score}) + + scored_hct.sort(key=lambda x: x["score"], reverse=True) + + # Choose distinct colours + chosen_colors = [] + for difference_degrees_ in range(90, 0, -1): + chosen_colors.clear() + for item in scored_hct: + hct = item["hct"] + duplicate_hue = any( + difference_degrees(hct.hue, chosen_hct.hue) < difference_degrees_ for chosen_hct in chosen_colors + ) + if not duplicate_hue: + chosen_colors.append(hct) + if len(chosen_colors) >= desired: + break + if len(chosen_colors) >= desired: + break + + # Get primary colour + primary = None + for cutoff in range(20, 0, -1): + for item in scored_hct: + if item["hct"].chroma > cutoff and item["hct"].tone > cutoff * 3: + primary = item["hct"] + break + if primary: + break + + # Choose distinct primaries + chosen_primaries = [primary] + for difference_degrees_ in range(90, 14, -1): + chosen_primaries = [primary] + for item in scored_hct: + hct = item["hct"] + duplicate_hue = any( + difference_degrees(hct.hue, chosen_hct.hue) < difference_degrees_ for chosen_hct in chosen_primaries + ) + if not duplicate_hue: + chosen_primaries.append(hct) + if len(chosen_primaries) >= 3: + break + if len(chosen_primaries) >= 3: + break + + # Fix disliked colours + if dislike_filter: + for i, chosen_hct in enumerate(chosen_primaries): + chosen_primaries[i] = DislikeAnalyzer.fix_if_disliked(chosen_hct) + for i, chosen_hct in enumerate(chosen_colors): + chosen_colors[i] = DislikeAnalyzer.fix_if_disliked(chosen_hct) + + return chosen_primaries, chosen_colors + + +def score(image: str) -> tuple[list[Hct], list[Hct]]: + return Score.score(ImageQuantizeCelebi(image, 1, 128)) + + +if __name__ == "__main__": + img = sys.argv[1] + mode = sys.argv[2] if len(sys.argv) > 2 else "hex" + + colours = Score.score(ImageQuantizeCelebi(img, 1, 128)) + for t in colours: + if mode != "hex": + print("".join(["\x1b[48;2;{};{};{}m \x1b[0m".format(*c.to_rgba()[:3]) for c in t])) + if mode != "swatch": + print(" ".join(["{:02X}{:02X}{:02X}".format(*c.to_rgba()[:3]) for c in t])) diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py index dfb57d9..6a6e0a8 100644 --- a/src/caelestia/utils/paths.py +++ b/src/caelestia/utils/paths.py @@ -1,16 +1,33 @@ +import hashlib import os from pathlib import Path config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) data_dir = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local/share")) state_dir = Path(os.getenv("XDG_STATE_HOME", Path.home() / ".local/state")) +cache_dir = Path(os.getenv("XDG_CACHE_HOME", Path.home() / ".cache")) c_config_dir = config_dir / "caelestia" c_data_dir = data_dir / "caelestia" c_state_dir = state_dir / "caelestia" +c_cache_dir = cache_dir / "caelestia" cli_data_dir = Path(__file__).parent.parent / "data" templates_dir = cli_data_dir / "templates" scheme_path = c_state_dir / "scheme.json" -scheme_data_path = cli_data_dir / "schemes" +scheme_data_dir = cli_data_dir / "schemes" +scheme_cache_dir = c_cache_dir / "schemes" + +last_wallpaper_path = c_state_dir / "wallpaper/last.txt" +wallpaper_thumbnail_path = c_state_dir / "wallpaper/thumbnail.jpg" + + +def compute_hash(path: str) -> str: + sha = hashlib.sha256() + + with open(path, "rb") as f: + while chunk := f.read(8192): + sha.update(chunk) + + return sha.hexdigest() diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index c26d2f8..66cd697 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -1,7 +1,8 @@ import json from pathlib import Path -from caelestia.utils.paths import scheme_data_path, scheme_path +from caelestia.utils.material import get_colours_for_image +from caelestia.utils.paths import scheme_data_dir, scheme_path class Scheme: @@ -89,7 +90,7 @@ class Scheme: return self._colours def get_colours_path(self) -> Path: - return (scheme_data_path / self.name / self.flavour / self.mode).with_suffix(".txt") + return (scheme_data_dir / self.name / self.flavour / self.mode).with_suffix(".txt") def save(self) -> None: scheme_path.parent.mkdir(parents=True, exist_ok=True) @@ -118,7 +119,10 @@ class Scheme: self._mode = get_scheme_modes()[0] def _update_colours(self) -> None: - self._colours = read_colours_from_file(self.get_colours_path()) + if self.name == "dynamic": + self._colours = get_colours_for_image() + else: + self._colours = read_colours_from_file(self.get_colours_path()) def __str__(self) -> str: return f"Scheme(name={self.name}, flavour={self.flavour}, mode={self.mode}, variant={self.variant})" @@ -168,7 +172,7 @@ def get_scheme_names() -> list[str]: global scheme_names if scheme_names is None: - scheme_names = [f.name for f in scheme_data_path.iterdir() if f.is_dir()] + scheme_names = [f.name for f in scheme_data_dir.iterdir() if f.is_dir()] scheme_names.append("dynamic") return scheme_names @@ -182,7 +186,7 @@ def get_scheme_flavours() -> list[str]: if name == "dynamic": scheme_flavours = ["default", "alt1", "alt2"] else: - scheme_flavours = [f.name for f in (scheme_data_path / name).iterdir() if f.is_dir()] + scheme_flavours = [f.name for f in (scheme_data_dir / name).iterdir() if f.is_dir()] return scheme_flavours @@ -192,6 +196,9 @@ def get_scheme_modes() -> list[str]: if scheme_modes is None: scheme = get_scheme() - scheme_modes = [f.stem for f in (scheme_data_path / scheme.name / scheme.flavour).iterdir() if f.is_file()] + if scheme.name == "dynamic": + scheme_modes = ["light", "dark"] + else: + scheme_modes = [f.stem for f in (scheme_data_dir / scheme.name / scheme.flavour).iterdir() if f.is_file()] return scheme_modes diff --git a/src/caelestia/utils/theme.py b/src/caelestia/utils/theme.py index 3250ea3..d205fb1 100644 --- a/src/caelestia/utils/theme.py +++ b/src/caelestia/utils/theme.py @@ -115,7 +115,7 @@ def apply_btop(colours: dict[str, str]) -> None: def apply_colours(colours: dict[str, str], mode: str) -> None: apply_terms(gen_sequences(colours)) - apply_hypr(gen_conf(colours)) + apply_hypr(gen_conf(colours)) # FIXME: LAGGY apply_discord(gen_scss(colours)) apply_spicetify(colours, mode) apply_fuzzel(colours) -- cgit v1.2.3-freya From 672ef4a2d9291fb4333e6d6aa807826d6860259a Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 16:00:43 +1000 Subject: scheme: impl random + fix single schemes --- src/caelestia/data/schemes/oldworld/dark.txt | 81 ---------------------- .../data/schemes/oldworld/default/dark.txt | 81 ++++++++++++++++++++++ src/caelestia/data/schemes/onedark/dark.txt | 81 ---------------------- .../data/schemes/onedark/default/dark.txt | 81 ++++++++++++++++++++++ src/caelestia/data/schemes/shadotheme/dark.txt | 81 ---------------------- .../data/schemes/shadotheme/default/dark.txt | 81 ++++++++++++++++++++++ src/caelestia/subcommands/scheme.py | 1 + src/caelestia/utils/material/generator.py | 2 +- src/caelestia/utils/scheme.py | 8 +++ 9 files changed, 253 insertions(+), 244 deletions(-) delete mode 100644 src/caelestia/data/schemes/oldworld/dark.txt create mode 100644 src/caelestia/data/schemes/oldworld/default/dark.txt delete mode 100644 src/caelestia/data/schemes/onedark/dark.txt create mode 100644 src/caelestia/data/schemes/onedark/default/dark.txt delete mode 100644 src/caelestia/data/schemes/shadotheme/dark.txt create mode 100644 src/caelestia/data/schemes/shadotheme/default/dark.txt (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/data/schemes/oldworld/dark.txt b/src/caelestia/data/schemes/oldworld/dark.txt deleted file mode 100644 index 846dc18..0000000 --- a/src/caelestia/data/schemes/oldworld/dark.txt +++ /dev/null @@ -1,81 +0,0 @@ -rosewater f4d3d3 -flamingo edbab5 -pink e29eca -mauve c99ee2 -red ea83a5 -maroon f49eba -peach f5a191 -yellow e6b99d -green 90b99f -teal 85b5ba -sky 69b6e0 -sapphire 5b9fba -blue 92a2d5 -lavender aca1cf -text c9c7cd -subtext1 9998a8 -subtext0 757581 -overlay2 57575f -overlay1 3e3e43 -overlay0 353539 -surface2 2a2a2d -surface1 27272a -surface0 1b1b1d -base 161617 -mantle 131314 -crust 101011 -success 90b99f -primary_paletteKeyColor 5A77AB -secondary_paletteKeyColor 6E778A -tertiary_paletteKeyColor 8A6E8E -neutral_paletteKeyColor 76777D -neutral_variant_paletteKeyColor 74777F -background 111318 -onBackground E2E2E9 -surface 111318 -surfaceDim 111318 -surfaceBright 37393E -surfaceContainerLowest 0C0E13 -surfaceContainerLow 191C20 -surfaceContainer 1E2025 -surfaceContainerHigh 282A2F -surfaceContainerHighest 33353A -onSurface E2E2E9 -surfaceVariant 44474E -onSurfaceVariant C4C6D0 -inverseSurface E2E2E9 -inverseOnSurface 2E3036 -outline 8E9099 -outlineVariant 44474E -shadow 000000 -scrim 000000 -surfaceTint ABC7FF -primary ABC7FF -onPrimary 0B305F -primaryContainer 284777 -onPrimaryContainer D7E3FF -inversePrimary 415E91 -secondary BEC6DC -onSecondary 283141 -secondaryContainer 3E4759 -onSecondaryContainer DAE2F9 -tertiary DDBCE0 -onTertiary 3F2844 -tertiaryContainer A587A9 -onTertiaryContainer 000000 -error FFB4AB -onError 690005 -errorContainer 93000A -onErrorContainer FFDAD6 -primaryFixed D7E3FF -primaryFixedDim ABC7FF -onPrimaryFixed 001B3F -onPrimaryFixedVariant 284777 -secondaryFixed DAE2F9 -secondaryFixedDim BEC6DC -onSecondaryFixed 131C2B -onSecondaryFixedVariant 3E4759 -tertiaryFixed FAD8FD -tertiaryFixedDim DDBCE0 -onTertiaryFixed 28132E -onTertiaryFixedVariant 573E5C \ No newline at end of file diff --git a/src/caelestia/data/schemes/oldworld/default/dark.txt b/src/caelestia/data/schemes/oldworld/default/dark.txt new file mode 100644 index 0000000..846dc18 --- /dev/null +++ b/src/caelestia/data/schemes/oldworld/default/dark.txt @@ -0,0 +1,81 @@ +rosewater f4d3d3 +flamingo edbab5 +pink e29eca +mauve c99ee2 +red ea83a5 +maroon f49eba +peach f5a191 +yellow e6b99d +green 90b99f +teal 85b5ba +sky 69b6e0 +sapphire 5b9fba +blue 92a2d5 +lavender aca1cf +text c9c7cd +subtext1 9998a8 +subtext0 757581 +overlay2 57575f +overlay1 3e3e43 +overlay0 353539 +surface2 2a2a2d +surface1 27272a +surface0 1b1b1d +base 161617 +mantle 131314 +crust 101011 +success 90b99f +primary_paletteKeyColor 5A77AB +secondary_paletteKeyColor 6E778A +tertiary_paletteKeyColor 8A6E8E +neutral_paletteKeyColor 76777D +neutral_variant_paletteKeyColor 74777F +background 111318 +onBackground E2E2E9 +surface 111318 +surfaceDim 111318 +surfaceBright 37393E +surfaceContainerLowest 0C0E13 +surfaceContainerLow 191C20 +surfaceContainer 1E2025 +surfaceContainerHigh 282A2F +surfaceContainerHighest 33353A +onSurface E2E2E9 +surfaceVariant 44474E +onSurfaceVariant C4C6D0 +inverseSurface E2E2E9 +inverseOnSurface 2E3036 +outline 8E9099 +outlineVariant 44474E +shadow 000000 +scrim 000000 +surfaceTint ABC7FF +primary ABC7FF +onPrimary 0B305F +primaryContainer 284777 +onPrimaryContainer D7E3FF +inversePrimary 415E91 +secondary BEC6DC +onSecondary 283141 +secondaryContainer 3E4759 +onSecondaryContainer DAE2F9 +tertiary DDBCE0 +onTertiary 3F2844 +tertiaryContainer A587A9 +onTertiaryContainer 000000 +error FFB4AB +onError 690005 +errorContainer 93000A +onErrorContainer FFDAD6 +primaryFixed D7E3FF +primaryFixedDim ABC7FF +onPrimaryFixed 001B3F +onPrimaryFixedVariant 284777 +secondaryFixed DAE2F9 +secondaryFixedDim BEC6DC +onSecondaryFixed 131C2B +onSecondaryFixedVariant 3E4759 +tertiaryFixed FAD8FD +tertiaryFixedDim DDBCE0 +onTertiaryFixed 28132E +onTertiaryFixedVariant 573E5C \ No newline at end of file diff --git a/src/caelestia/data/schemes/onedark/dark.txt b/src/caelestia/data/schemes/onedark/dark.txt deleted file mode 100644 index 269096e..0000000 --- a/src/caelestia/data/schemes/onedark/dark.txt +++ /dev/null @@ -1,81 +0,0 @@ -rosewater edcbc5 -flamingo d3a4a4 -pink d792c6 -mauve c678dd -red be5046 -maroon e06c75 -peach d19a66 -yellow e5c07b -green 98c379 -teal 56b6c2 -sky 90ccd7 -sapphire 389dcc -blue 61afef -lavender 8e98d9 -text abb2bf -subtext1 95a0b5 -subtext0 838b9c -overlay2 767f8f -overlay1 666e7c -overlay0 5c6370 -surface2 4b5263 -surface1 3c414f -surface0 30343e -base 282c34 -mantle 21242b -crust 1e2126 -success 98c379 -primary_paletteKeyColor 5878AB -secondary_paletteKeyColor 6E778A -tertiary_paletteKeyColor 896E8F -neutral_paletteKeyColor 75777D -neutral_variant_paletteKeyColor 74777F -background 111318 -onBackground E1E2E9 -surface 111318 -surfaceDim 111318 -surfaceBright 37393E -surfaceContainerLowest 0C0E13 -surfaceContainerLow 191C20 -surfaceContainer 1D2024 -surfaceContainerHigh 282A2F -surfaceContainerHighest 33353A -onSurface E1E2E9 -surfaceVariant 43474E -onSurfaceVariant C4C6CF -inverseSurface E1E2E9 -inverseOnSurface 2E3035 -outline 8E9099 -outlineVariant 43474E -shadow 000000 -scrim 000000 -surfaceTint A8C8FF -primary A8C8FF -onPrimary 06305F -primaryContainer 254777 -onPrimaryContainer D5E3FF -inversePrimary 3F5F90 -secondary BDC7DC -onSecondary 273141 -secondaryContainer 40495B -onSecondaryContainer D9E3F8 -tertiary DBBCE1 -onTertiary 3E2845 -tertiaryContainer A387AA -onTertiaryContainer 000000 -error FFB4AB -onError 690005 -errorContainer 93000A -onErrorContainer FFDAD6 -primaryFixed D5E3FF -primaryFixedDim A8C8FF -onPrimaryFixed 001B3C -onPrimaryFixedVariant 254777 -secondaryFixed D9E3F8 -secondaryFixedDim BDC7DC -onSecondaryFixed 121C2B -onSecondaryFixedVariant 3E4758 -tertiaryFixed F8D8FE -tertiaryFixedDim DBBCE1 -onTertiaryFixed 28132F -onTertiaryFixedVariant 563E5D \ No newline at end of file diff --git a/src/caelestia/data/schemes/onedark/default/dark.txt b/src/caelestia/data/schemes/onedark/default/dark.txt new file mode 100644 index 0000000..269096e --- /dev/null +++ b/src/caelestia/data/schemes/onedark/default/dark.txt @@ -0,0 +1,81 @@ +rosewater edcbc5 +flamingo d3a4a4 +pink d792c6 +mauve c678dd +red be5046 +maroon e06c75 +peach d19a66 +yellow e5c07b +green 98c379 +teal 56b6c2 +sky 90ccd7 +sapphire 389dcc +blue 61afef +lavender 8e98d9 +text abb2bf +subtext1 95a0b5 +subtext0 838b9c +overlay2 767f8f +overlay1 666e7c +overlay0 5c6370 +surface2 4b5263 +surface1 3c414f +surface0 30343e +base 282c34 +mantle 21242b +crust 1e2126 +success 98c379 +primary_paletteKeyColor 5878AB +secondary_paletteKeyColor 6E778A +tertiary_paletteKeyColor 896E8F +neutral_paletteKeyColor 75777D +neutral_variant_paletteKeyColor 74777F +background 111318 +onBackground E1E2E9 +surface 111318 +surfaceDim 111318 +surfaceBright 37393E +surfaceContainerLowest 0C0E13 +surfaceContainerLow 191C20 +surfaceContainer 1D2024 +surfaceContainerHigh 282A2F +surfaceContainerHighest 33353A +onSurface E1E2E9 +surfaceVariant 43474E +onSurfaceVariant C4C6CF +inverseSurface E1E2E9 +inverseOnSurface 2E3035 +outline 8E9099 +outlineVariant 43474E +shadow 000000 +scrim 000000 +surfaceTint A8C8FF +primary A8C8FF +onPrimary 06305F +primaryContainer 254777 +onPrimaryContainer D5E3FF +inversePrimary 3F5F90 +secondary BDC7DC +onSecondary 273141 +secondaryContainer 40495B +onSecondaryContainer D9E3F8 +tertiary DBBCE1 +onTertiary 3E2845 +tertiaryContainer A387AA +onTertiaryContainer 000000 +error FFB4AB +onError 690005 +errorContainer 93000A +onErrorContainer FFDAD6 +primaryFixed D5E3FF +primaryFixedDim A8C8FF +onPrimaryFixed 001B3C +onPrimaryFixedVariant 254777 +secondaryFixed D9E3F8 +secondaryFixedDim BDC7DC +onSecondaryFixed 121C2B +onSecondaryFixedVariant 3E4758 +tertiaryFixed F8D8FE +tertiaryFixedDim DBBCE1 +onTertiaryFixed 28132F +onTertiaryFixedVariant 563E5D \ No newline at end of file diff --git a/src/caelestia/data/schemes/shadotheme/dark.txt b/src/caelestia/data/schemes/shadotheme/dark.txt deleted file mode 100644 index e178804..0000000 --- a/src/caelestia/data/schemes/shadotheme/dark.txt +++ /dev/null @@ -1,81 +0,0 @@ -rosewater f1c4e0 -flamingo F18FB0 -pink a8899c -mauve E9729D -red B52A5B -maroon FF4971 -peach ff79c6 -yellow 8897F4 -green 6a5acd -teal F18FB0 -sky 4484d1 -sapphire 2f77a1 -blue bd93f9 -lavender 849BE0 -text e3c7fc -subtext1 CBB2E1 -subtext0 B39DC7 -overlay2 9A88AC -overlay1 827392 -overlay0 6A5D77 -surface2 52485D -surface1 393342 -surface0 211E28 -base 09090d -mantle 060608 -crust 030304 -success 37d4a7 -primary_paletteKeyColor 6F72AC -secondary_paletteKeyColor 75758B -tertiary_paletteKeyColor 936B83 -neutral_paletteKeyColor 78767D -neutral_variant_paletteKeyColor 777680 -background 131318 -onBackground E4E1E9 -surface 131318 -surfaceDim 131318 -surfaceBright 39383F -surfaceContainerLowest 0E0E13 -surfaceContainerLow 1B1B21 -surfaceContainer 1F1F25 -surfaceContainerHigh 2A292F -surfaceContainerHighest 35343A -onSurface E4E1E9 -surfaceVariant 46464F -onSurfaceVariant C7C5D0 -inverseSurface E4E1E9 -inverseOnSurface 303036 -outline 918F9A -outlineVariant 46464F -shadow 000000 -scrim 000000 -surfaceTint BFC1FF -primary BFC1FF -onPrimary 282B60 -primaryContainer 3F4178 -onPrimaryContainer E1E0FF -inversePrimary 565992 -secondary C5C4DD -onSecondary 2E2F42 -secondaryContainer 47475B -onSecondaryContainer E2E0F9 -tertiary E8B9D4 -onTertiary 46263B -tertiaryContainer AF849D -onTertiaryContainer 000000 -error FFB4AB -onError 690005 -errorContainer 93000A -onErrorContainer FFDAD6 -primaryFixed E1E0FF -primaryFixedDim BFC1FF -onPrimaryFixed 12144B -onPrimaryFixedVariant 3F4178 -secondaryFixed E2E0F9 -secondaryFixedDim C5C4DD -onSecondaryFixed 191A2C -onSecondaryFixedVariant 454559 -tertiaryFixed FFD8ED -tertiaryFixedDim E8B9D4 -onTertiaryFixed 2E1125 -onTertiaryFixedVariant 5F3C52 \ No newline at end of file diff --git a/src/caelestia/data/schemes/shadotheme/default/dark.txt b/src/caelestia/data/schemes/shadotheme/default/dark.txt new file mode 100644 index 0000000..e178804 --- /dev/null +++ b/src/caelestia/data/schemes/shadotheme/default/dark.txt @@ -0,0 +1,81 @@ +rosewater f1c4e0 +flamingo F18FB0 +pink a8899c +mauve E9729D +red B52A5B +maroon FF4971 +peach ff79c6 +yellow 8897F4 +green 6a5acd +teal F18FB0 +sky 4484d1 +sapphire 2f77a1 +blue bd93f9 +lavender 849BE0 +text e3c7fc +subtext1 CBB2E1 +subtext0 B39DC7 +overlay2 9A88AC +overlay1 827392 +overlay0 6A5D77 +surface2 52485D +surface1 393342 +surface0 211E28 +base 09090d +mantle 060608 +crust 030304 +success 37d4a7 +primary_paletteKeyColor 6F72AC +secondary_paletteKeyColor 75758B +tertiary_paletteKeyColor 936B83 +neutral_paletteKeyColor 78767D +neutral_variant_paletteKeyColor 777680 +background 131318 +onBackground E4E1E9 +surface 131318 +surfaceDim 131318 +surfaceBright 39383F +surfaceContainerLowest 0E0E13 +surfaceContainerLow 1B1B21 +surfaceContainer 1F1F25 +surfaceContainerHigh 2A292F +surfaceContainerHighest 35343A +onSurface E4E1E9 +surfaceVariant 46464F +onSurfaceVariant C7C5D0 +inverseSurface E4E1E9 +inverseOnSurface 303036 +outline 918F9A +outlineVariant 46464F +shadow 000000 +scrim 000000 +surfaceTint BFC1FF +primary BFC1FF +onPrimary 282B60 +primaryContainer 3F4178 +onPrimaryContainer E1E0FF +inversePrimary 565992 +secondary C5C4DD +onSecondary 2E2F42 +secondaryContainer 47475B +onSecondaryContainer E2E0F9 +tertiary E8B9D4 +onTertiary 46263B +tertiaryContainer AF849D +onTertiaryContainer 000000 +error FFB4AB +onError 690005 +errorContainer 93000A +onErrorContainer FFDAD6 +primaryFixed E1E0FF +primaryFixedDim BFC1FF +onPrimaryFixed 12144B +onPrimaryFixedVariant 3F4178 +secondaryFixed E2E0F9 +secondaryFixedDim C5C4DD +onSecondaryFixed 191A2C +onSecondaryFixedVariant 454559 +tertiaryFixed FFD8ED +tertiaryFixedDim E8B9D4 +onTertiaryFixed 2E1125 +onTertiaryFixedVariant 5F3C52 \ No newline at end of file diff --git a/src/caelestia/subcommands/scheme.py b/src/caelestia/subcommands/scheme.py index e149d13..973cfce 100644 --- a/src/caelestia/subcommands/scheme.py +++ b/src/caelestia/subcommands/scheme.py @@ -15,6 +15,7 @@ class Command: if self.args.random: scheme.set_random() + apply_colours(scheme.colours, scheme.mode) elif self.args.name or self.args.flavour or self.args.mode: if self.args.name: scheme.name = self.args.name diff --git a/src/caelestia/utils/material/generator.py b/src/caelestia/utils/material/generator.py index 33ff0e8..235b2ce 100755 --- a/src/caelestia/utils/material/generator.py +++ b/src/caelestia/utils/material/generator.py @@ -187,6 +187,6 @@ def gen_scheme(scheme, primary: Hct, colours: list[Hct]) -> dict[str, str]: colours["success"] = harmonize(base[8], primary) # For debugging - print("\n".join(["{}: \x1b[48;2;{};{};{}m \x1b[0m".format(n, *c.to_rgba()[:3]) for n, c in colours.items()])) + # print("\n".join(["{}: \x1b[48;2;{};{};{}m \x1b[0m".format(n, *c.to_rgba()[:3]) for n, c in colours.items()])) return {k: hex(v.to_int())[4:] for k, v in colours.items()} diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index 66cd697..ce8d6fe 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -1,4 +1,5 @@ import json +import random from pathlib import Path from caelestia.utils.material import get_colours_for_image @@ -106,6 +107,13 @@ class Scheme: f, ) + def set_random(self) -> None: + self._name = random.choice(get_scheme_names()) + self._flavour = random.choice(get_scheme_flavours()) + self._mode = random.choice(get_scheme_modes()) + self._update_colours() + self.save() + def _check_flavour(self) -> None: global scheme_flavours scheme_flavours = None -- cgit v1.2.3-freya From e701e85af0f354a0d52a7d84ff22459f3760e6ae Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 16:18:01 +1000 Subject: scheme: better print --- src/caelestia/utils/scheme.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index ce8d6fe..f25cf62 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -133,7 +133,15 @@ class Scheme: self._colours = read_colours_from_file(self.get_colours_path()) def __str__(self) -> str: - return f"Scheme(name={self.name}, flavour={self.flavour}, mode={self.mode}, variant={self.variant})" + return ( + f"Current scheme:\n" + f" Name: {self.name}\n" + f" Flavour: {self.flavour}\n" + f" Mode: {self.mode}\n" + f" Variant: {self.variant}\n" + f" Colours:\n" + f" {'\n '.join(f'{n}: \x1b[38;2;{int(c[0:2], 16)};{int(c[2:4], 16)};{int(c[4:6], 16)}m{c}\x1b[0m' for n, c in self.colours.items())}" + ) scheme_variants = [ -- cgit v1.2.3-freya From e75e727262573de25ee1e1e75bd93e3647dc3609 Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 16:23:14 +1000 Subject: scheme: add variant option Remove variant subcommand --- src/caelestia/parser.py | 22 ++-------------------- src/caelestia/subcommands/scheme.py | 4 +++- src/caelestia/subcommands/variant.py | 11 ----------- src/caelestia/utils/scheme.py | 5 +++++ 4 files changed, 10 insertions(+), 32 deletions(-) delete mode 100644 src/caelestia/subcommands/variant.py (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py index 9718938..3f6f506 100644 --- a/src/caelestia/parser.py +++ b/src/caelestia/parser.py @@ -1,18 +1,6 @@ import argparse -from caelestia.subcommands import ( - clipboard, - emoji, - pip, - record, - scheme, - screenshot, - shell, - toggle, - variant, - wallpaper, - wsaction, -) +from caelestia.subcommands import clipboard, emoji, pip, record, scheme, screenshot, shell, toggle, wallpaper, wsaction from caelestia.utils.scheme import get_scheme_names, scheme_variants @@ -65,13 +53,7 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace): scheme_parser.add_argument("-n", "--name", choices=get_scheme_names(), help="the name of the scheme to switch to") scheme_parser.add_argument("-f", "--flavour", help="the flavour to switch to") scheme_parser.add_argument("-m", "--mode", choices=["dark", "light"], help="the mode to switch to") - - # Create parser for variant opts - variant_parser = command_parser.add_parser("variant", help="manage the dynamic scheme variant") - variant_parser.set_defaults(cls=variant.Command) - variant_parser.add_argument("-g", "--get", action="store_true", help="print the current dynamic scheme variant") - variant_parser.add_argument("-s", "--set", choices=scheme_variants, help="set the current dynamic scheme variant") - variant_parser.add_argument("-r", "--random", action="store_true", help="switch to a random variant") + scheme_parser.add_argument("-v", "--variant", choices=scheme_variants, help="the variant to switch to") # Create parser for screenshot opts screenshot_parser = command_parser.add_parser("screenshot", help="take a screenshot") diff --git a/src/caelestia/subcommands/scheme.py b/src/caelestia/subcommands/scheme.py index 973cfce..c95df96 100644 --- a/src/caelestia/subcommands/scheme.py +++ b/src/caelestia/subcommands/scheme.py @@ -16,13 +16,15 @@ class Command: if self.args.random: scheme.set_random() apply_colours(scheme.colours, scheme.mode) - elif self.args.name or self.args.flavour or self.args.mode: + elif self.args.name or self.args.flavour or self.args.mode or self.args.variant: if self.args.name: scheme.name = self.args.name if self.args.flavour: scheme.flavour = self.args.flavour if self.args.mode: scheme.mode = self.args.mode + if self.args.variant: + scheme.variant = self.args.variant apply_colours(scheme.colours, scheme.mode) else: print(scheme) diff --git a/src/caelestia/subcommands/variant.py b/src/caelestia/subcommands/variant.py deleted file mode 100644 index 37f9a2b..0000000 --- a/src/caelestia/subcommands/variant.py +++ /dev/null @@ -1,11 +0,0 @@ -from argparse import Namespace - - -class Command: - args: Namespace - - def __init__(self, args: Namespace) -> None: - self.args = args - - def run(self) -> None: - pass diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index f25cf62..c978231 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -84,7 +84,12 @@ class Scheme: @variant.setter def variant(self, variant: str) -> None: + if variant == self._variant: + return + self._variant = variant + self._update_colours() + self.save() @property def colours(self) -> dict[str, str]: -- cgit v1.2.3-freya From a53a2568ec6e4e53d32a48443f50eee9d9fb8fcd Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 16:49:01 +1000 Subject: scheme: fix not saving atomically Causes programs which rely on the save file (e.g. the shell) to fail occasionally as they try to read while the cli is writing --- src/caelestia/utils/paths.py | 10 ++++++++++ src/caelestia/utils/scheme.py | 23 +++++++++++------------ 2 files changed, 21 insertions(+), 12 deletions(-) (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py index 6a6e0a8..3b5a7a6 100644 --- a/src/caelestia/utils/paths.py +++ b/src/caelestia/utils/paths.py @@ -1,5 +1,8 @@ import hashlib +import json import os +import shutil +import tempfile from pathlib import Path config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config")) @@ -31,3 +34,10 @@ def compute_hash(path: str) -> str: sha.update(chunk) return sha.hexdigest() + + +def atomic_dump(path: Path, content: dict[str, any]) -> None: + with tempfile.NamedTemporaryFile("w") as f: + json.dump(content, f) + f.flush() + shutil.move(f.name, path) diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index c978231..9027589 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -3,7 +3,7 @@ import random from pathlib import Path from caelestia.utils.material import get_colours_for_image -from caelestia.utils.paths import scheme_data_dir, scheme_path +from caelestia.utils.paths import atomic_dump, scheme_data_dir, scheme_path class Scheme: @@ -100,17 +100,16 @@ class Scheme: def save(self) -> None: scheme_path.parent.mkdir(parents=True, exist_ok=True) - with scheme_path.open("w") as f: - json.dump( - { - "name": self.name, - "flavour": self.flavour, - "mode": self.mode, - "variant": self.variant, - "colours": self.colours, - }, - f, - ) + atomic_dump( + scheme_path, + { + "name": self.name, + "flavour": self.flavour, + "mode": self.mode, + "variant": self.variant, + "colours": self.colours, + }, + ) def set_random(self) -> None: self._name = random.choice(get_scheme_names()) -- cgit v1.2.3-freya From c043a14ca24f70e81b69133350a1174d2e6572fc Mon Sep 17 00:00:00 2001 From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com> Date: Thu, 12 Jun 2025 21:35:05 +1000 Subject: feat: impl wallpaper --- src/caelestia/parser.py | 12 +++- src/caelestia/subcommands/wallpaper.py | 12 +++- src/caelestia/utils/paths.py | 7 +- src/caelestia/utils/scheme.py | 12 ++-- src/caelestia/utils/wallpaper.py | 123 +++++++++++++++++++++++++++++++++ 5 files changed, 154 insertions(+), 12 deletions(-) create mode 100644 src/caelestia/utils/wallpaper.py (limited to 'src/caelestia/utils/scheme.py') diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py index 3f6f506..f8c7bac 100644 --- a/src/caelestia/parser.py +++ b/src/caelestia/parser.py @@ -1,7 +1,9 @@ import argparse from caelestia.subcommands import clipboard, emoji, pip, record, scheme, screenshot, shell, toggle, wallpaper, wsaction +from caelestia.utils.paths import wallpapers_dir from caelestia.utils.scheme import get_scheme_names, scheme_variants +from caelestia.utils.wallpaper import get_wallpaper def parse_args() -> (argparse.ArgumentParser, argparse.Namespace): @@ -81,14 +83,18 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace): # Create parser for wallpaper opts wallpaper_parser = command_parser.add_parser("wallpaper", help="manage the wallpaper") wallpaper_parser.set_defaults(cls=wallpaper.Command) - wallpaper_parser.add_argument("-g", "--get", action="store_true", help="print the current wallpaper") - wallpaper_parser.add_argument("-r", "--random", action="store_true", help="switch to a random wallpaper") + wallpaper_parser.add_argument( + "-p", "--print", nargs="?", const=get_wallpaper(), metavar="PATH", help="print the scheme for a wallpaper" + ) + wallpaper_parser.add_argument( + "-r", "--random", nargs="?", const=wallpapers_dir, metavar="DIR", help="switch to a random wallpaper" + ) wallpaper_parser.add_argument("-f", "--file", help="the path to the wallpaper to switch to") wallpaper_parser.add_argument("-n", "--no-filter", action="store_true", help="do not filter by size") wallpaper_parser.add_argument( "-t", "--threshold", - default=80, + default=0.8, help="the minimum percentage of the largest monitor size the image must be greater than to be selected", ) wallpaper_parser.add_argument( diff --git a/src/caelestia/subcommands/wallpaper.py b/src/caelestia/subcommands/wallpaper.py index 37f9a2b..1440484 100644 --- a/src/caelestia/subcommands/wallpaper.py +++ b/src/caelestia/subcommands/wallpaper.py @@ -1,5 +1,8 @@ +import json from argparse import Namespace +from caelestia.utils.wallpaper import get_colours_for_wall, get_wallpaper, set_random, set_wallpaper + class Command: args: Namespace @@ -8,4 +11,11 @@ class Command: self.args = args def run(self) -> None: - pass + if self.args.print: + print(json.dumps(get_colours_for_wall(self.args.print, self.args.no_smart))) + elif self.args.file: + set_wallpaper(self.args.file, self.args.no_smart) + elif self.args.random: + set_random(self.args) + else: + print(get_wallpaper()) diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py index 3b5a7a6..f81b996 100644 --- a/src/caelestia/utils/paths.py +++ b/src/caelestia/utils/paths.py @@ -22,11 +22,14 @@ scheme_path = c_state_dir / "scheme.json" scheme_data_dir = cli_data_dir / "schemes" scheme_cache_dir = c_cache_dir / "schemes" -last_wallpaper_path = c_state_dir / "wallpaper/last.txt" +wallpapers_dir = Path.home() / "Pictures/Wallpapers" +wallpaper_path_path = c_state_dir / "wallpaper/path.txt" +wallpaper_link_path = c_state_dir / "wallpaper/current" wallpaper_thumbnail_path = c_state_dir / "wallpaper/thumbnail.jpg" +thumbnail_cache_dir = c_cache_dir / "thumbnails" -def compute_hash(path: str) -> str: +def compute_hash(path: Path | str) -> str: sha = hashlib.sha256() with open(path, "rb") as f: diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py index 9027589..0d6cfb5 100644 --- a/src/caelestia/utils/scheme.py +++ b/src/caelestia/utils/scheme.py @@ -59,8 +59,7 @@ class Scheme: self._flavour = flavour self._check_mode() - self._update_colours() - self.save() + self.update_colours() @property def mode(self) -> str: @@ -75,8 +74,7 @@ class Scheme: raise ValueError(f'Invalid scheme mode: "{mode}". Valid modes: {get_scheme_modes()}') self._mode = mode - self._update_colours() - self.save() + self.update_colours() @property def variant(self) -> str: @@ -88,8 +86,7 @@ class Scheme: return self._variant = variant - self._update_colours() - self.save() + self.update_colours() @property def colours(self) -> dict[str, str]: @@ -115,6 +112,9 @@ class Scheme: self._name = random.choice(get_scheme_names()) self._flavour = random.choice(get_scheme_flavours()) self._mode = random.choice(get_scheme_modes()) + self.update_colours() + + def update_colours(self) -> None: self._update_colours() self.save() diff --git a/src/caelestia/utils/wallpaper.py b/src/caelestia/utils/wallpaper.py new file mode 100644 index 0000000..c8b3a72 --- /dev/null +++ b/src/caelestia/utils/wallpaper.py @@ -0,0 +1,123 @@ +import random +from argparse import Namespace +from pathlib import Path + +from materialyoucolor.hct import Hct +from materialyoucolor.utils.color_utils import argb_from_rgb +from PIL import Image + +from caelestia.utils.hypr import message +from caelestia.utils.material import get_colours_for_image +from caelestia.utils.paths import ( + compute_hash, + thumbnail_cache_dir, + wallpaper_link_path, + wallpaper_path_path, + wallpaper_thumbnail_path, +) +from caelestia.utils.scheme import Scheme, get_scheme +from caelestia.utils.theme import apply_colours + + +def is_valid_image(path: Path | str) -> bool: + path = Path(path) + return path.is_file() and path.suffix in [".jpg", ".jpeg", ".png", ".webp", ".tif", ".tiff"] + + +def check_wall(wall: Path, filter_size: tuple[int, int], threshold: float) -> bool: + with Image.open(wall) as img: + width, height = img.size + return width >= filter_size[0] * threshold and height >= filter_size[1] * threshold + + +def get_wallpaper() -> str: + return wallpaper_path_path.read_text() + + +def get_wallpapers(args: Namespace) -> list[Path]: + dir = Path(args.random) + if not dir.is_dir(): + return [] + + walls = [f for f in dir.rglob("*") if is_valid_image(f)] + + if args.no_filter: + return walls + + monitors = message("monitors") + filter_size = monitors[0]["width"], monitors[0]["height"] + for monitor in monitors[1:]: + if filter_size[0] > monitor["width"]: + filter_size[0] = monitor["width"] + if filter_size[1] > monitor["height"]: + filter_size[1] = monitor["height"] + + return [f for f in walls if check_wall(f, filter_size, args.threshold)] + + +def get_thumb(wall: Path) -> Path: + thumb = (thumbnail_cache_dir / compute_hash(wall)).with_suffix(".jpg") + + if not thumb.exists(): + with Image.open(wall) as img: + img = img.convert("RGB") + img.thumbnail((128, 128), Image.NEAREST) + thumb.parent.mkdir(parents=True, exist_ok=True) + img.save(thumb, "JPEG") + + return thumb + + +def get_smart_mode(wall: Path) -> str: + with Image.open(get_thumb(wall)) as img: + img.thumbnail((1, 1), Image.LANCZOS) + tone = Hct.from_int(argb_from_rgb(*img.getpixel((0, 0)))).tone + return "light" if tone > 60 else "dark" + + +def get_colours_for_wall(wall: Path | str, no_smart: bool) -> None: + scheme = get_scheme() + + if not no_smart: + scheme = Scheme( + { + "name": scheme.name, + "flavour": scheme.flavour, + "mode": get_smart_mode(wall), + "variant": scheme.variant, + "colours": scheme.colours, + } + ) + + return get_colours_for_image(get_thumb(wall), scheme) + + +def set_wallpaper(wall: Path | str, no_smart: bool) -> None: + if not is_valid_image(wall): + raise ValueError(f'"{wall}" is not a valid image') + + # Update files + wallpaper_path_path.parent.mkdir(parents=True, exist_ok=True) + wallpaper_path_path.write_text(str(wall)) + wallpaper_link_path.parent.mkdir(parents=True, exist_ok=True) + wallpaper_link_path.unlink(missing_ok=True) + wallpaper_link_path.symlink_to(wall) + + # Generate thumbnail or get from cache + thumb = get_thumb(wall) + wallpaper_thumbnail_path.parent.mkdir(parents=True, exist_ok=True) + wallpaper_thumbnail_path.unlink(missing_ok=True) + wallpaper_thumbnail_path.symlink_to(thumb) + + scheme = get_scheme() + + # Change mode based on wallpaper colour + scheme.mode = get_smart_mode(wall) + + # Update colours + scheme.update_colours() + apply_colours(scheme.colours, scheme.mode) + + +def set_random(args: Namespace) -> None: + set_wallpaper(random.choice(get_wallpapers(args)), args.no_smart) -- cgit v1.2.3-freya