1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
import json
import os
import random
import subprocess
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,
user_config_path,
wallpaper_link_path,
wallpaper_path_path,
wallpaper_thumbnail_path,
wallpapers_cache_dir,
)
from caelestia.utils.scheme import Scheme, get_scheme
from caelestia.utils.theme import apply_colours
def is_valid_image(path: Path) -> bool:
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:
try:
return wallpaper_path_path.read_text()
except IOError:
return None
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 = min(m["width"] for m in monitors), min(m["height"] for m in monitors)
return [f for f in walls if check_wall(f, filter_size, args.threshold)]
def get_thumb(wall: Path, cache: Path) -> Path:
thumb = cache / "thumbnail.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_opts(wall: Path, cache: Path) -> str:
opts_cache = cache / "smart.json"
try:
return json.loads(opts_cache.read_text())
except (IOError, json.JSONDecodeError):
pass
from caelestia.utils.colourfulness import get_variant
opts = {}
with Image.open(get_thumb(wall, cache)) as img:
opts["variant"] = get_variant(img)
img.thumbnail((1, 1), Image.LANCZOS)
hct = Hct.from_int(argb_from_rgb(*img.getpixel((0, 0))))
opts["mode"] = "light" if hct.tone > 60 else "dark"
opts_cache.parent.mkdir(parents=True, exist_ok=True)
with opts_cache.open("w") as f:
json.dump(opts, f)
return opts
def get_colours_for_wall(wall: Path | str, no_smart: bool) -> None:
scheme = get_scheme()
cache = wallpapers_cache_dir / compute_hash(wall)
name = "dynamic"
if not no_smart:
smart_opts = get_smart_opts(wall, cache)
scheme = Scheme(
{
"name": name,
"flavour": "default",
"mode": smart_opts["mode"],
"variant": smart_opts["variant"],
"colours": scheme.colours,
}
)
return {
"name": name,
"flavour": "default",
"mode": scheme.mode,
"variant": scheme.variant,
"colours": get_colours_for_image(get_thumb(wall, cache), scheme),
}
def set_wallpaper(wall: Path | str, no_smart: bool) -> None:
# Make path absolute
wall = Path(wall).resolve()
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)
cache = wallpapers_cache_dir / compute_hash(wall)
# Generate thumbnail or get from cache
thumb = get_thumb(wall, cache)
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 and variant based on wallpaper colour
if scheme.name == "dynamic" and not no_smart:
smart_opts = get_smart_opts(wall, cache)
scheme.mode = smart_opts["mode"]
scheme.variant = smart_opts["variant"]
# Update colours
scheme.update_colours()
apply_colours(scheme.colours, scheme.mode)
# Run custom post-hook if configured
try:
cfg = json.loads(user_config_path.read_text()).get("wallpaper", {})
if post_hook := cfg.get("postHook"):
subprocess.run(
post_hook,
shell=True,
env={**os.environ, "WALLPAPER_PATH": str(wall)},
stderr=subprocess.DEVNULL,
)
except (FileNotFoundError, json.JSONDecodeError):
pass
def set_random(args: Namespace) -> None:
wallpapers = get_wallpapers(args)
if not wallpapers:
raise ValueError("No valid wallpapers found")
try:
last_wall = wallpaper_path_path.read_text()
wallpapers.remove(Path(last_wall))
if not wallpapers:
raise ValueError("Only valid wallpaper is current")
except (FileNotFoundError, ValueError):
pass
set_wallpaper(random.choice(wallpapers), args.no_smart)
|
