omarchy-dms 0.1.0__py3-none-any.whl

omarchy_dms/__init__.py

@@ -0,0 +1,24 @@
+"""Omarchy themes as DMS profiles.
+
+Library first: `ops.Omarchy` is the API (no printing, no exiting, progress goes
+to a `log` callback); `cli` is one thin frontend over it. Other frontends import
+this package instead of shelling out to the CLI.
+"""
+
+from .dms import Dms, DmsError
+from .ops import Omarchy, Row, store_repos
+from .store import Store, StoreError, Theme, resolve_repo
+from .theme import ThemeError
+
+__all__ = [
+    "Dms",
+    "DmsError",
+    "Omarchy",
+    "Row",
+    "Store",
+    "StoreError",
+    "Theme",
+    "ThemeError",
+    "resolve_repo",
+    "store_repos",
+]

omarchy_dms/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

omarchy_dms/cli.py

@@ -0,0 +1,92 @@
+"""Command line frontend over ops.Omarchy."""
+
+import argparse
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from . import theme
+from .dms import Dms, DmsError
+from .ops import Omarchy, store_repos
+from .store import Store, StoreError
+
+HOME = Path.home()
+THEMES = HOME / ".config/DankMaterialShell/themes"
+WALLPAPERS = HOME / "Pictures/Wallpapers/omarchy"
+
+
+def _hook_command():
+    exe = shutil.which("omarchy-dms")
+    return f"{shlex.quote(exe)} hook" if exe else f"{shlex.quote(sys.executable)} -m omarchy_dms hook"
+
+
+def _pick(items, prompt, multi):
+    if not shutil.which("fzf"):
+        raise StoreError("fzf not found: pass the name(s) as arguments")
+    cmd = ["fzf", "--prompt", prompt, *(["-m"] if multi else [])]
+    r = subprocess.run(cmd, input="\n".join(items), text=True, stdout=subprocess.PIPE, check=False)
+    return r.stdout.split()
+
+
+def _parser():
+    p = argparse.ArgumentParser(prog="omarchy-dms", description="Omarchy themes as DMS profiles.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    s = sub.add_parser("sync", help="create profiles for Omarchy's own themes (all, or the ones named)")
+    s.add_argument("--force", action="store_true", help="recreate the ones that exist")
+    s.add_argument("themes", nargs="*")
+    s = sub.add_parser("install", help="install a community theme and create its profile")
+    s.add_argument("repo", nargs="?", help="owner/repo or git URL (none: pick from omarchy.org/themes)")
+    s = sub.add_parser("update", help="refresh themes installed with install (all, or the ones named)")
+    s.add_argument("themes", nargs="*")
+    s = sub.add_parser("remove", help="remove theme, wallpapers and profile (none named: pick with fzf)")
+    s.add_argument("-y", "--yes", action="store_true", help="do not ask")
+    s.add_argument("themes", nargs="*")
+    sub.add_parser("installed", help="every theme, where it comes from, profile or not")
+    sub.add_parser("list", help="repos listed on omarchy.org/themes")
+    s = sub.add_parser("render", help="convert a colors.toml into a DMS theme folder")
+    s.add_argument("colors")
+    s.add_argument("slug")
+    s.add_argument("outdir")
+    sub.add_parser("hook", help="dmsProfiles apply command (reads DMS_PROFILE_SLUG)")
+    return p
+
+
+def main(argv=None):
+    args = _parser().parse_args(argv)
+    builtin = Path(os.environ["OMARCHY_THEMES"]) if "OMARCHY_THEMES" in os.environ else None
+    omarchy = Omarchy(Dms(), Store(THEMES, WALLPAPERS), builtin, _hook_command())
+    try:
+        match args.cmd:
+            case "sync":
+                omarchy.sync(args.themes, args.force)
+            case "install":
+                repo = args.repo or next(iter(_pick(store_repos(), "omarchy theme> ", False)), None)
+                if repo:
+                    omarchy.install(repo)
+            case "update":
+                return 1 if omarchy.update(args.themes) else 0
+            case "remove":
+                names = args.themes or _pick(omarchy.store.slugs(), "remove (Tab marks)> ", True)
+                if names and not args.yes:
+                    print(f"remove: {' '.join(names)}")
+                    if input("continue? [y/N] ") != "y":
+                        return 0
+                if names:
+                    omarchy.remove(names)
+            case "installed":
+                for row in omarchy.installed():
+                    origin = row.origin or "community (no .source: reinstall to track)"
+                    print(f"{row.slug:<22} {'profile' if row.profile else '-':<8} {origin}")
+            case "list":
+                print("\n".join(store_repos()))
+            case "render":
+                theme.render(args.colors, args.slug, args.outdir)
+            case "hook":
+                omarchy.hook(os.environ.get("DMS_PROFILE_SLUG", ""))
+    except (DmsError, StoreError, theme.ThemeError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    return 0

omarchy_dms/dms.py

@@ -0,0 +1,132 @@
+"""Thin client for the DMS shell over `dms ipc`.
+
+`runner` is the only thing that touches the process table, so a frontend or a
+test can swap it. Calls the plugin finishes asynchronously (create, remove,
+apply) are polled until the shell reports the result, instead of sleeping.
+"""
+
+import contextlib
+import json
+import subprocess
+import time
+from collections.abc import Callable
+
+Runner = Callable[[list[str]], str]
+
+
+class DmsError(RuntimeError):
+    pass
+
+
+def run_dms(args):
+    try:
+        p = subprocess.run(["dms", *args], capture_output=True, text=True, check=False)
+    except FileNotFoundError as e:
+        raise DmsError("dms not found in PATH") from e
+    if p.returncode:
+        raise DmsError(f"dms {' '.join(args)}: {p.stderr.strip() or p.stdout.strip()}")
+    return p.stdout.strip()
+
+
+class Dms:
+    def __init__(
+        self,
+        runner: Runner = run_dms,
+        sleep=time.sleep,
+        attempts=60,
+        interval=0.25,
+        spawn: Callable[..., object] = subprocess.Popen,
+    ):
+        self._run = runner
+        self._sleep = sleep
+        self.attempts = attempts
+        self.interval = interval
+        self._spawn = spawn
+
+    def ipc(self, *args):
+        return self._run(["ipc", "call", *args])
+
+    def _json(self, *args):
+        out = self.ipc(*args)
+        try:
+            return json.loads(out or "null")
+        except json.JSONDecodeError as e:
+            raise DmsError(f"dms ipc call {' '.join(args)}: not JSON: {out[:80]!r}") from e
+
+    def _wait(self, what, ok):
+        for _ in range(self.attempts):
+            if ok():
+                return
+            self._sleep(self.interval)
+        raise DmsError(f"timed out waiting for {what}")
+
+    # -- reading
+    def profiles(self):
+        return self._json("profiles", "list") or []
+
+    def find_profile(self, slug, name):
+        return next((p for p in self.profiles() if p.get("slug") == slug or p.get("name") == name), None)
+
+    def status(self):
+        return self._json("profiles", "status") or {}
+
+    def active(self):
+        return self.status().get("active", "")
+
+    def snapshot(self):
+        return self._json("profiles", "snapshot") or {}
+
+    # -- profiles
+    def set_option(self, key, value):
+        self.ipc("profiles", "setOption", key, value)
+
+    @contextlib.contextmanager
+    def autosave_paused(self):
+        """Autosave would write each theme change into the previously active profile."""
+        self.set_option("autosave", "false")
+        try:
+            yield
+        finally:
+            self.set_option("autosave", "true")
+
+    def create_profile(self, name):
+        self.ipc("profiles", "create", name)
+        self._wait(f"profile {name!r}", lambda: any(p.get("name") == name for p in self.profiles()))
+
+    def remove_profile(self, slug):
+        self.ipc("profiles", "remove", slug)
+        self._wait(f"profile {slug!r} to go", lambda: all(p.get("slug") != slug for p in self.profiles()))
+
+    def apply_profile(self, slug):
+        self.ipc("profiles", "apply", slug)
+
+        def done():
+            s = self.status()
+            return s.get("active") == slug and not s.get("switching")
+
+        self._wait(f"profile {slug!r} to apply", done)
+
+    # -- the look itself
+    def custom_theme(self, theme_json, theme_id):
+        self.ipc("profiles", "customTheme", str(theme_json), theme_id, "default", "default", "default", "both")
+        self._wait("theme", lambda: self.snapshot().get("settings", {}).get("customThemeFile") == str(theme_json))
+
+    def set_mode(self, mode):
+        self.ipc("theme", mode)
+        self._wait(f"{mode} mode", lambda: self.snapshot().get("session", {}).get("isLightMode") == (mode == "light"))
+
+    def set_wallpaper(self, path):
+        out = self.ipc("wallpaper", "set", str(path))
+        if out.startswith("ERROR"):
+            raise DmsError(out)
+        self._wait("wallpaper", lambda: self.snapshot().get("session", {}).get("wallpaperPath") == str(path))
+
+    def set_wallpaper_later(self, path, delay=2):
+        """Detached, so the caller (dmsProfiles' apply command) returns at once."""
+        self._spawn(
+            ["sh", "-c", 'sleep "$1"; exec dms ipc call wallpaper set "$2"', "_", str(delay), str(path)],
+            start_new_session=True,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )

omarchy_dms/ops.py

@@ -0,0 +1,178 @@
+"""What omarchy-dms does, as an API: sync, install, update, remove, installed, hook.
+
+No printing and no exiting: progress goes to `log`, problems are exceptions
+(DmsError, StoreError, ThemeError), results are returned.
+"""
+
+import re
+import time
+import urllib.error
+import urllib.request
+from collections.abc import Callable
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import theme
+from .dms import Dms
+from .store import Store, StoreError, resolve_repo
+
+STORE_URL = "https://omarchy.org/themes/"
+NOT_COMMUNITY = {"basecamp", "omacom"}
+
+
+@dataclass(frozen=True)
+class Row:
+    slug: str
+    profile: bool
+    origin: str  # "built-in", the repo URL, or "" for a community theme with no .source
+
+
+def store_repos():
+    """Repos listed on omarchy.org/themes, as owner/repo."""
+    req = urllib.request.Request(STORE_URL, headers={"User-Agent": "omarchy-dms"})
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:  # noqa: S310 (fixed https URL)
+            html = r.read().decode("utf-8", "replace")
+    except (urllib.error.URLError, TimeoutError) as e:
+        raise StoreError(f"{STORE_URL}: {e}") from e
+    repos = set(re.findall(r"https://github\.com/([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)", html))
+    return sorted(r for r in repos if r.split("/")[0] not in NOT_COMMUNITY)
+
+
+class Omarchy:
+    def __init__(
+        self,
+        dms: Dms,
+        store: Store,
+        builtin_dir: Path | None = None,
+        hook_command: str = "omarchy-dms hook",
+        log: Callable[[str], None] = print,
+        settle: float = 1.0,
+        sleep=time.sleep,
+    ):
+        self.dms = dms
+        self.store = store
+        self.builtin_dir = Path(builtin_dir) if builtin_dir else None
+        self.hook_command = hook_command
+        self.log = log
+        self.settle = settle
+        self._sleep = sleep
+
+    # -- internals
+    @contextmanager
+    def _session(self):
+        """Autosave off, the wallpaper hook registered, and a way back (Original)."""
+        with self.dms.autosave_paused():
+            self.dms.set_option("applyCommand", self.hook_command)
+            if not self.dms.find_profile("original", "Original"):
+                self.log("create: Original")
+                self.dms.create_profile("Original")
+            yield
+
+    def _make(self, slug, mode, force):
+        name = theme.profile_name(slug)
+        existing = self.dms.find_profile(slug, name)
+        if existing:
+            if not force:
+                self.log(f"skip: {name}")
+                return
+            self.dms.remove_profile(existing["slug"])
+        if not self.store.theme_json(slug).is_file():
+            raise StoreError(f"{slug}: theme folder missing (deploy the Home Manager config first)")
+        self.dms.custom_theme(self.store.theme_json(slug), f"omarchy-{slug}")
+        self.dms.set_mode(mode)
+        images = self.store.images(slug)
+        if images:
+            self.dms.set_wallpaper(images[0])
+        self._sleep(self.settle)
+        self.log(f"create: {name}")
+        self.dms.create_profile(name)
+
+    # -- operations
+    def installed(self):
+        names = {p.get("slug") for p in self.dms.profiles()} | {p.get("name") for p in self.dms.profiles()}
+        return [
+            Row(
+                t.slug,
+                t.slug in names or theme.profile_name(t.slug) in names,
+                "built-in" if t.builtin else (t.source or ""),
+            )
+            for t in self.store.themes()
+        ]
+
+    def sync(self, names=(), force=False):
+        """Profiles for Omarchy's own themes (all, or the ones named)."""
+        if not self.builtin_dir or not self.builtin_dir.is_dir():
+            raise StoreError("Omarchy's own themes are not available (OMARCHY_THEMES is not set)")
+        available = {p.parent.name: p for p in sorted(self.builtin_dir.glob("*/colors.toml"))}
+        unknown = [n for n in names if n not in available]
+        if unknown:
+            raise StoreError(f"not an Omarchy theme: {', '.join(unknown)}")
+        with self._session():
+            for slug, colors in available.items():
+                if not names or slug in names:
+                    self._make(slug, theme.mode_of(theme.load_palette(colors)), force)
+
+    def install(self, arg):
+        """Install a community theme (owner/repo or git URL); returns its slug."""
+        url, slug = resolve_repo(arg)
+        mode = self.store.fetch(url, slug)
+        with self._session():
+            self._make(slug, mode, force=True)  # reinstalling refreshes the profile
+        return slug
+
+    def update(self, names=()):
+        """Refetch installed community themes; returns the slugs that failed.
+
+        Profiles are left alone: they point at theme.json by path, so the colors
+        follow; `install` again to also refresh a profile's own wallpaper copy.
+        """
+        by_slug = {t.slug: t for t in self.store.themes()}
+        for n in names:
+            if n not in by_slug or not by_slug[n].source:
+                self.log(f"not updatable (no .source): {n}")
+        targets = [t for t in by_slug.values() if t.source and (not names or t.slug in names)]
+        if not targets and not names:
+            self.log("no installed community themes (reinstall them once with: omarchy-dms install <repo>)")
+        failed = []
+        for t in targets:
+            self.log(f"update: {t.slug} ({t.source})")
+            try:
+                self.store.fetch(t.source, t.slug)
+            except (StoreError, theme.ThemeError) as e:
+                self.log(f"failed: {t.slug}: {e}")
+                failed.append(t.slug)
+        return failed
+
+    def remove(self, names):
+        """Delete themes: files, wallpapers and profile. Built-ins only lose the profile."""
+        known = set(self.store.slugs())
+        unknown = [n for n in names if n not in known]
+        if unknown:
+            raise StoreError(f"unknown theme: {', '.join(unknown)}")
+        with self.dms.autosave_paused():
+            active = self.dms.active()
+            original = self.dms.find_profile("original", "Original")
+            for slug in names:
+                prof = self.dms.find_profile(slug, theme.profile_name(slug))
+                if prof:
+                    if active == prof["slug"] and original and original["slug"] != active:
+                        self.dms.apply_profile(original["slug"])  # leave it before deleting it
+                        active = original["slug"]
+                    self.dms.remove_profile(prof["slug"])
+                if self.store.remove(slug):
+                    self.log(f"removed: {slug}")
+                else:
+                    self.log(f"removed profile: {slug} (built-in files are managed by Nix; sync recreates it)")
+
+    def hook(self, slug):
+        """dmsProfiles apply command: point the wallpaper back at the whole theme folder.
+
+        A profile carries one wallpaper copy (plus its thumbnail), which is all
+        the carousel would list. dmsProfiles sets its own wallpaper *after* this
+        command, so the change lands a moment later.
+        """
+        images = self.store.images(slug)
+        if images:
+            self.dms.set_wallpaper_later(images[0])

omarchy_dms/store.py

@@ -0,0 +1,131 @@
+"""Theme folders and wallpapers on disk, and fetching community themes.
+
+Built-in themes (Omarchy's own, deployed by Nix) are symlinks into the store and
+read-only; community ones are real folders this module owns.
+"""
+
+import re
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import theme
+
+IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png", ".webp"}
+MIN_IMAGE_BYTES = 2048  # drops the ~700-byte placeholders
+SLUG_RE = re.compile(r"[a-z0-9_][a-z0-9._+-]*")
+SHORTHAND_RE = re.compile(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+")
+
+
+class StoreError(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class Theme:
+    slug: str
+    builtin: bool
+    source: str | None
+
+
+def resolve_repo(arg):
+    """owner/repo or a git URL -> (url, slug). Same naming as omarchy-theme-install."""
+    arg = arg.strip()
+    if arg.startswith(("https://", "ssh://", "git@")):
+        url = arg
+    elif SHORTHAND_RE.fullmatch(arg):
+        url = f"https://github.com/{arg}"
+    else:
+        raise StoreError("expected owner/repo or a git URL")
+    name = arg.rstrip("/").removesuffix(".git").rsplit("/", 1)[-1].rsplit(":", 1)[-1].lower()
+    slug = name.removeprefix("omarchy-").removesuffix("-theme")
+    if not SLUG_RE.fullmatch(slug):
+        raise StoreError(f"unusable theme name: {slug!r}")
+    return url, slug
+
+
+class Store:
+    def __init__(self, themes_dir, wall_dir):
+        self.themes_dir = Path(themes_dir)
+        self.wall_dir = Path(wall_dir)
+
+    def theme_dir(self, slug):
+        return self.themes_dir / f"omarchy-{slug}"
+
+    def theme_json(self, slug):
+        return self.theme_dir(slug) / "theme.json"
+
+    def wallpapers(self, slug):
+        return self.wall_dir / slug
+
+    def slugs(self):
+        # .source counts too: a community theme whose theme.json went missing can still be updated.
+        return sorted(
+            d.name.removeprefix("omarchy-")
+            for d in self.themes_dir.glob("omarchy-*")
+            if (d / "theme.json").is_file() or (d / ".source").is_file()
+        )
+
+    def is_builtin(self, slug):
+        return self.theme_json(slug).is_symlink() or self.wallpapers(slug).is_symlink()
+
+    def source(self, slug):
+        f = self.theme_dir(slug) / ".source"
+        return f.read_text().strip() if f.is_file() else None
+
+    def themes(self):
+        return [Theme(s, self.is_builtin(s), self.source(s)) for s in self.slugs()]
+
+    def images(self, slug):
+        d = self.wallpapers(slug)
+        return sorted(p for p in d.iterdir() if p.is_file()) if d.is_dir() else []
+
+    def fetch(self, url, slug):
+        """Clone URL and (re)write the theme folder and wallpapers; return the mode."""
+        if not SLUG_RE.fullmatch(slug):
+            raise StoreError(f"unusable theme name: {slug!r}")
+        if self.is_builtin(slug):
+            raise StoreError(f"{slug} is one of Omarchy's built-in themes")
+        with tempfile.TemporaryDirectory() as tmp:
+            repo = Path(tmp) / "repo"
+            r = subprocess.run(
+                ["git", "clone", "--quiet", "--depth", "1", "--", url, str(repo)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if r.returncode:
+                raise StoreError(f"git clone {url}: {r.stderr.strip()}")
+            colors = repo / "colors.toml"
+            if not colors.is_file():
+                raise StoreError(f"{url} has no colors.toml (alacritty-only themes are not supported)")
+            mode = theme.render(colors, slug, self.theme_dir(slug))
+            walls = self.wallpapers(slug)
+            walls.mkdir(parents=True, exist_ok=True)
+            backgrounds = repo / "backgrounds"
+            for img in sorted(backgrounds.iterdir()) if backgrounds.is_dir() else []:
+                if (
+                    img.is_file()
+                    and not img.is_symlink()
+                    and img.suffix.lower() in IMAGE_SUFFIXES
+                    and img.stat().st_size > MIN_IMAGE_BYTES
+                ):
+                    shutil.copyfile(img, walls / img.name)
+        # Remembered so `update` can fetch it again.
+        (self.theme_dir(slug) / ".source").write_text(url + "\n")
+        return mode
+
+    def remove(self, slug):
+        """Delete a community theme and its wallpapers; False for a built-in one."""
+        if slug not in self.slugs():
+            raise StoreError(f"unknown theme: {slug}")
+        if self.is_builtin(slug):
+            return False
+        try:
+            shutil.rmtree(self.theme_dir(slug))
+            shutil.rmtree(self.wallpapers(slug), ignore_errors=True)
+        except OSError as e:
+            raise StoreError(f"cannot remove {slug}: {e}") from e
+        return True

omarchy_dms/theme.py

@@ -0,0 +1,156 @@
+"""Omarchy colors.toml -> DMS custom theme folder (theme.json + Browse previews).
+
+Pure: no DMS, no network. Omarchy has no Material roles, so the mapping is an
+approximation. Community themes come in two shapes: the derived palette
+(accent, selection, red, ...) and a plain ANSI one (color0..color15). Whatever is
+missing is derived from background/foreground and the ANSI colors.
+"""
+
+import json
+import pathlib
+import string
+import tomllib
+
+REQUIRED = ("background", "foreground", "accent")
+FONT = 'font-family="system-ui, sans-serif"'
+
+
+class ThemeError(ValueError):
+    pass
+
+
+def _rgb(h):
+    h = h.lstrip("#")
+    if len(h) in (3, 4):
+        h = "".join(ch * 2 for ch in h)
+    try:
+        return tuple(int(h[i : i + 2], 16) for i in (0, 2, 4))
+    except ValueError as e:
+        raise ThemeError(f"bad color {h!r}") from e
+
+
+def _hexed(t):
+    r, g, b = (round(v) for v in t)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def _mix(a, b, t):
+    return _hexed(tuple(x * (1 - t) + y * t for x, y in zip(_rgb(a), _rgb(b), strict=True)))
+
+
+def _luminance(h):
+    r, g, b = (v / 255 for v in _rgb(h))
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+
+def profile_name(slug):
+    return string.capwords(slug.replace("-", " "))
+
+
+def load_palette(path):
+    try:
+        palette = tomllib.loads(pathlib.Path(path).read_text())
+    except (OSError, tomllib.TOMLDecodeError) as e:
+        raise ThemeError(f"{path}: {e}") from e
+    missing = [k for k in REQUIRED if k not in palette]
+    if missing:
+        raise ThemeError(f"{path}: missing {', '.join(missing)}")
+    return palette
+
+
+def mode_of(palette):
+    return palette.get("mode") or ("light" if _luminance(palette["background"]) > 0.5 else "dark")
+
+
+def convert(palette, slug):
+    bg, fg, accent = palette["background"], palette["foreground"], palette["accent"]
+    light = mode_of(palette) == "light"
+    raise_to = "#000000" if light else "#ffffff"
+
+    def pick(*keys, default):
+        return next((palette[k] for k in keys if k in palette), default)
+
+    dark_bg = pick("dark_background", default=_mix(bg, "#000000", 0.05 if light else 0.15))
+    darker_bg = pick("darker_background", default=_mix(bg, "#000000", 0.1 if light else 0.3))
+    lighter_bg = pick("lighter_background", default=_mix(bg, raise_to, 0.08))
+    # selection_background in the ANSI shape is often a loud highlight, so not used.
+    selection = pick("selection", default=_mix(bg, raise_to, 0.16))
+
+    colors = {
+        "primary": accent,
+        "primaryText": bg,
+        "primaryContainer": selection,
+        "secondary": pick("magenta", "color5", default=accent),
+        "surface": bg,
+        "surfaceText": fg,
+        "surfaceVariant": dark_bg if light else lighter_bg,
+        "surfaceVariantText": fg,
+        "surfaceTint": accent,
+        "background": bg if light else dark_bg,
+        "backgroundText": pick("bright_foreground", default=fg),
+        "outline": pick("muted", "color8", default=_mix(fg, bg, 0.5)),
+        "surfaceContainerLowest": bg if light else darker_bg,
+        "surfaceContainerLow": bg if light else dark_bg,
+        "surfaceContainer": dark_bg if light else lighter_bg,
+        "surfaceContainerHigh": darker_bg if light else selection,
+        "error": pick("red", "color1", default=accent),
+        "warning": pick("yellow", "color3", default=accent),
+        "info": pick("blue", "color4", default=accent),
+    }
+    return {
+        "id": f"omarchy-{slug}",
+        "name": f"Omarchy {profile_name(slug)}",
+        "version": "1.0.0",
+        "author": "Omarchy",
+        "description": f"Omarchy {slug} palette",
+        "dark": colors,
+        "light": colors,
+    }
+
+
+def preview(theme, mode):
+    c = theme["dark"]
+    title = f"{theme['name']} ({mode})"
+    return f"""<svg xmlns="http://www.w3.org/2000/svg" width="280" height="240" viewBox="0 0 280 240">
+  <rect width="280" height="240" fill="{c["background"]}"/>
+  <rect width="280" height="26" fill="{c["surface"]}"/>
+  <rect x="12" y="9" width="20" height="8" rx="4" fill="{c["primary"]}"/>
+  <circle cx="40" cy="13" r="3" fill="{c["surfaceVariantText"]}"/>
+  <circle cx="50" cy="13" r="3" fill="{c["surfaceVariantText"]}"/>
+  <text x="140" y="17" {FONT} font-size="10" font-weight="600" text-anchor="middle" fill="{c["primary"]}">9:41</text>
+  <circle cx="238" cy="13" r="4" fill="{c["info"]}"/>
+  <circle cx="252" cy="13" r="4" fill="{c["warning"]}"/>
+  <circle cx="266" cy="13" r="4" fill="{c["error"]}"/>
+  <rect x="14" y="38" width="252" height="190" rx="12" fill="{c["surface"]}" stroke="{c["outline"]}" stroke-opacity="0.5"/>
+  <text x="28" y="61" {FONT} font-size="12.5" font-weight="600" fill="{c["surfaceText"]}">{title}</text>
+  <text x="28" y="77" {FONT} font-size="9.5" fill="{c["surfaceVariantText"]}">Secondary text</text>
+  <rect x="26" y="87" width="228" height="50" rx="8" fill="{c["surfaceContainerHigh"]}"/>
+  <text x="38" y="105" {FONT} font-size="10" font-weight="500" fill="{c["surfaceText"]}">Nested card</text>
+  <text x="38" y="120" {FONT} font-size="9" fill="{c["surfaceVariantText"]}">Body text on an elevated surface</text>
+  <rect x="26" y="145" width="228" height="22" rx="6" fill="{c["surface"]}" stroke="{c["outline"]}" stroke-opacity="0.4"/>
+  <text x="38" y="160" {FONT} font-size="9" fill="{c["surfaceVariantText"]}">Search</text>
+  <rect x="26" y="175" width="78" height="22" rx="11" fill="{c["primary"]}"/>
+  <text x="65" y="190" {FONT} font-size="9.5" font-weight="600" text-anchor="middle" fill="{c["primaryText"]}">Button</text>
+  <rect x="112" y="175" width="70" height="22" rx="11" fill="{c["primary"]}" fill-opacity="0.15"/>
+  <text x="147" y="190" {FONT} font-size="9.5" font-weight="500" text-anchor="middle" fill="{c["primary"]}">Accent</text>
+  <rect x="190" y="175" width="64" height="22" rx="11" fill="{c["surfaceContainerHigh"]}"/>
+  <text x="222" y="190" {FONT} font-size="9.5" text-anchor="middle" fill="{c["surfaceText"]}">Chip</text>
+  <circle cx="34" cy="212" r="7" fill="{c["primary"]}"/>
+  <circle cx="54" cy="212" r="7" fill="{c["secondary"]}"/>
+  <circle cx="74" cy="212" r="7" fill="{c["error"]}"/>
+  <circle cx="94" cy="212" r="7" fill="{c["warning"]}"/>
+  <circle cx="114" cy="212" r="7" fill="{c["info"]}"/>
+</svg>
+"""
+
+
+def render(colors_toml, slug, outdir):
+    """Write theme.json and the two Browse previews into OUTDIR; return the mode."""
+    palette = load_palette(colors_toml)
+    theme = convert(palette, slug)
+    out = pathlib.Path(outdir)
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "theme.json").write_text(json.dumps(theme, indent=2) + "\n")
+    for mode in ("dark", "light"):
+        (out / f"preview-{mode}.svg").write_text(preview(theme, mode))
+    return mode_of(palette)

omarchy_dms-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: omarchy-dms
+Version: 0.1.0
+Summary: Omarchy themes as Dank Material Shell (dmsProfiles) looks
+Author: Mikel Villota
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Villoh/omarchy-dms
+Project-URL: Issues, https://github.com/Villoh/omarchy-dms/issues
+Keywords: omarchy,dms,dankmaterialshell,theme,dmsprofiles
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Desktop Environment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# omarchy-dms
+
+Use [Omarchy](https://omarchy.org) themes in [Dank Material Shell](https://danklinux.com)
+as [dmsProfiles](https://github.com/satoshoe-dev/dms-profiles) looks: colors, wallpapers
+and light/dark mode, switchable from the profile picker.
+
+It converts an Omarchy `colors.toml` into a DMS custom theme (with the Browse previews),
+copies the theme's wallpapers, and creates one profile per theme through `dms ipc`.
+Themes from the [omarchy.org/themes](https://omarchy.org/themes/) store install with one command.
+
+## Requirements
+
+DMS with the `dmsProfiles` plugin enabled, Python 3.11+, `git`, and optionally `fzf`
+(pickers). No other dependencies.
+
+## Install
+
+```sh
+pipx install omarchy-dms
+# or, from the repository
+pipx install git+https://github.com/Villoh/omarchy-dms
+```
+
+On Nix: `nix run github:Villoh/omarchy-dms`.
+
+## Usage
+
+```sh
+omarchy-dms install                      # pick from the omarchy.org/themes store (fzf)
+omarchy-dms install owner/repo           # or a repo / git URL
+omarchy-dms installed                    # every theme, its origin, and whether it has a profile
+omarchy-dms update [theme...]            # refetch installed themes (all, or the ones named)
+omarchy-dms remove [-y] [theme...]       # theme, wallpapers and profile (no names: fzf, Tab marks)
+omarchy-dms list                         # repos listed on the store
+omarchy-dms sync [--force] [theme...]    # profiles for Omarchy's own themes (see below)
+```
+
+Themes land in `~/.config/DankMaterialShell/themes/omarchy-<name>/` and wallpapers in
+`~/Pictures/Wallpapers/omarchy/<name>/`. Only themes with a `colors.toml` work; alacritty-only
+themes are rejected.
+
+**Own themes.** `sync` needs Omarchy's own `themes/` directory, given by `OMARCHY_THEMES`
+(for example a checkout of `basecamp/omarchy`), with the theme folders already in place
+for DMS: `omarchy-dms render <colors.toml> <name> <outdir>` writes one.
+
+**Wallpaper carousel.** dmsProfiles stores one wallpaper copy per profile. The CLI registers
+itself as the profile *apply command* so that, after a switch, the wallpaper points back at the
+theme's folder and a carousel lists all of its images.
+
+## As a library
+
+`omarchy_dms.Omarchy(dms, store, ...)` is the API behind the CLI: it never prints or exits,
+progress goes to a `log` callback and failures are exceptions (`DmsError`, `StoreError`,
+`ThemeError`). Another frontend can import it instead of running the CLI.
+
+```python
+from omarchy_dms import Dms, Omarchy, Store
+
+omarchy = Omarchy(Dms(), Store(themes_dir, wallpapers_dir), log=print)
+omarchy.install("owner/omarchy-example-theme")
+```
+
+## Development
+
+```sh
+uv sync
+uv run python -m unittest discover -s tests
+uv run ruff check . && uv run ruff format --check .
+```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` (the Nix package reads it from there), commit, then tag it:
+
+```sh
+git tag v0.1.0 && git push origin v0.1.0
+```
+
+`.github/workflows/release.yml` does the rest: it checks the tag against the version, runs CI,
+builds and smoke-tests the package, publishes it to PyPI with trusted publishing, and creates the
+GitHub release. Its notes are `.github/release-notes/<tag>.md` if you wrote one, otherwise
+the ones GitHub generates from merged pull requests.
+
+## License
+
+[MIT](LICENSE)

omarchy_dms-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+omarchy_dms/__init__.py,sha256=tI51D_-QAhZ5vcpgPABDotIrJ6Qy_r-XN-OaWhSY1f0,582
+omarchy_dms/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+omarchy_dms/cli.py,sha256=itSD_2Dy4tXR88daRkSDHnFIe7FeEhHTr0tp3N6qlaA,3962
+omarchy_dms/dms.py,sha256=VO5bUU1jmVW0Lp1_zb0Ge7114Omb39LKTJ8RQDcQQdI,4382
+omarchy_dms/ops.py,sha256=OPrgmO3qE7gZNS6eKuWxhVYipYX8GhwPFgds_pWZndI,7214
+omarchy_dms/store.py,sha256=0fJb4gbjfpwUPTFtJ6t99oxgA5L3Jm5LQsxaaeFbEGw,4741
+omarchy_dms/theme.py,sha256=wqJ-GENooVwpOKM0s2hN3THT-p_UUpwSOwv9h2yT1WY,6702
+omarchy_dms-0.1.0.dist-info/licenses/LICENSE,sha256=hkEhFFC3gg9l89-tV41jm_lOVXOwWNiVcHnjSJx8Zlc,1070
+omarchy_dms-0.1.0.dist-info/METADATA,sha256=OOWDPWmmvm2f61Q_v3MNimpwdIF-0WF8y-BnQO_YvMQ,3998
+omarchy_dms-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+omarchy_dms-0.1.0.dist-info/entry_points.txt,sha256=C8jyEhOYeZt4Z6dytnFt7ur6zQKk87ydDTI62Bx0UJo,53
+omarchy_dms-0.1.0.dist-info/top_level.txt,sha256=vegHpJfKNIIsuMlyNO62hfsFjNoY3C_4Kc1VKhr7wew,12
+omarchy_dms-0.1.0.dist-info/RECORD,,

omarchy_dms-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

omarchy_dms-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+omarchy-dms = omarchy_dms.cli:main

omarchy_dms-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mikel Villota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

omarchy_dms-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+omarchy_dms