hadalized 0.4.0__py3-none-any.whl

hadalized/homedirs.py

@@ -0,0 +1,69 @@
+"""XDG base directories the application uses."""
+
+from pathlib import Path  # required for pydantic
+
+import xdg_base_dirs
+
+from hadalized.const import APP_NAME
+
+APP_DIR = Path(APP_NAME)
+
+
+def config() -> Path:
+    """Application user configuration home.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return xdg_base_dirs.xdg_config_home() / APP_DIR
+
+
+def cache() -> Path:
+    """Application cache home.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return xdg_base_dirs.xdg_cache_home() / APP_DIR
+
+
+def state() -> Path:
+    """Application state home.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return xdg_base_dirs.xdg_state_home() / APP_DIR
+
+
+def data() -> Path:
+    """Application data home.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return xdg_base_dirs.xdg_data_home() / APP_DIR
+
+
+def template() -> Path:
+    """Application user config templates home.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return config() / "templates"
+
+
+def build() -> Path:
+    """Application home for built themes.
+
+    Returns:
+        The application configuration home directory.
+
+    """
+    return state() / "build"

hadalized/options.py

@@ -0,0 +1,134 @@
+"""Common configuration options. Passed to many objects and CLI functions."""
+
+from pathlib import Path
+from typing import Annotated, Any
+
+from cyclopts.parameter import Parameter
+from pydantic import AfterValidator, Field
+
+from hadalized import homedirs
+from hadalized.base import BaseNode
+
+
+def validate_nullable_path(val: str | Path | None) -> Path | None:
+    """Convert special values of `null` or `none` to None.
+
+    Returns:
+        A ``Path`` instance or None.
+
+    """
+    match str(val).lower():
+        case "null" | "none":
+            out = None
+        case _:
+            out = Path(val) if isinstance(val, str) else val
+    return out
+
+
+@Parameter(name="*")
+class Options(BaseNode):
+    """Common options available to all CLI commands and configuration."""
+
+    # fixme: Annotated[
+    #     Path | None,
+    #     Parameter(alias=["--fix"]),
+    #     AfterValidator(validate_nullable_path),
+    # ] = None
+    include_builds: Annotated[
+        list[str],
+        Parameter(name="app", alias=["-a"], negative=""),
+    ] = Field(default=[])
+    """Application themes to build. The elements must correspond to a
+    ``Config.builds`` key, which is typically an application name.
+    If not specified, all applications in ``Config.builds`` will be
+    generated.
+    """
+    cache_dir: Annotated[Path, Parameter(parse=True)] = homedirs.cache()
+    """Location of cache directory."""
+    config_file: Path | None = None
+    """Specify a toml file to load configuration from. When specified,
+    the standard configurations specified in ``UserConfig`` are ignored.
+    """
+    cache_in_memory: Annotated[bool, Parameter(negative="")] = False
+    """Whether to use in-memory application cache."""
+    dry_run: Annotated[bool, Parameter(alias="-n", negative="")] = False
+    """Do not output any files or write to cache."""
+    force: Annotated[bool, Parameter(alias="-f", negative="")] = False
+    """Force rewriting of files. If set during theme building, files will
+    be regenerated and cache populated."""
+    no_cache: Annotated[bool, Parameter(negative="")] = False
+    """Ignore cache completely. If set during theme building, hash digests
+    of generated files will not be cached."""
+    no_config: Annotated[bool, Parameter(negative="")] = False
+    """Do not read settings from user config files. Implies `--no-templates`."""
+    no_templates: Annotated[bool, Parameter(negative="")] = False
+    """Ignore user defined templates. Implied by `--no-config`."""
+    output_dir: Annotated[
+        Path | None,
+        Parameter(alias=["--output", "--out", "-o"]),
+        AfterValidator(validate_nullable_path),
+    ] = Field(
+        default=None,
+        examples=[Path("./build"), Path("./colors")],
+    )
+    """Directory to copy built theme files to or output files."""
+    parse: Annotated[bool, Parameter(negative="")] = False
+    """Whether palette colors should be parsed and expanded upon loading."""
+    include_palettes: Annotated[
+        list[str],
+        Parameter(name="palette", alias=["-p"], negative=""),
+    ] = Field(default=[])
+    """Palettes to include when building application theme files. The
+    items must include a key or alias in the ``Config.palettes`` definitions.
+    If not specified, all defined palettes will be utilized.
+    """
+    prefix: Annotated[bool, Parameter(negative="")] = False
+    """When set in conjunction with an output directory, built themes will
+    be placed in a subdirectory determined by built theme file's parent
+    directory. Typically this is just the applicate name, e.g., 'neovim'."""
+    quiet: Annotated[bool, Parameter(alias="-q", negative="")] = False
+    """Suppress logging to stdout."""
+    state_dir: Annotated[Path, Parameter(parse=True)] = homedirs.state()
+    """Directory containing application state such as built theme files."""
+    template_dir: Annotated[Path, Parameter(parse=True)] = homedirs.template()
+    """Directory where templates will be searched for initially. If a template
+    is not found in this directory, it will be loaded from those defined in the
+    package."""
+    verbose: Annotated[bool, Parameter(alias="-v", negative="")] = False
+    """Log more details."""
+
+    def model_post_init(self, context: Any, /) -> None:
+        """Check if settings do not conflict.
+
+        Raises:
+            ValueError: When mutually exclusive options are set.
+
+
+        """
+        if self.verbose and self.quiet:
+            raise ValueError("Cannot set both verbose and quiet.")
+        if self.no_cache and self.cache_in_memory:
+            raise ValueError("Cannot set both no_cache and cache_in_memory.")
+        if self.no_config and self.config_file:
+            raise ValueError("Cannot set both no_config and config_file.")
+
+        return super().model_post_init(context)
+
+    @property
+    def build_dir(self) -> Path:
+        """Location of built theme files."""
+        return self.state_dir / "build"
+
+    @property
+    def use_cache(self) -> bool:
+        """Opposite of `no_cache`."""
+        return not self.no_cache
+
+    @property
+    def use_templates(self) -> bool:
+        """Whether to use user-defined templates.
+
+        False if ``no_config`` is set.
+
+        """
+        return not self.no_config and not self.no_templates

hadalized/palette.py

@@ -0,0 +1,133 @@
+"""Schema for a color palette.
+
+A palette is the primary context used to render a color theme.
+"""
+
+from typing import Literal, Self
+
+from pydantic import Field, PrivateAttr
+
+from hadalized.base import BaseNode
+from hadalized.color import (
+    Bases,
+    ColorFieldHandler,
+    ColorFieldType,
+    ColorMap,
+    Extractor,
+    Grayscale,
+    Hues,
+    Parser,
+)
+
+
+class PaletteMeta(BaseNode):
+    """Palette metadata."""
+
+    name: str
+    desc: str
+    version: str = "2.1"
+    """Version of the palette color definitions."""
+    mode: Literal["dark", "light"]
+    """Whether the theme is dark or light mode."""
+    gamut: str = "srgb"
+    """Gamut to fit to when parsing."""
+    aliases: list[str] = Field(default=[])
+    """Palette aliases."""
+
+
+class PaletteColors(BaseNode):
+    """Palette color maps."""
+
+    hue: Hues
+    """Named main color hues."""
+    base: Bases
+    """Named bases relative to the palette."""
+    bright: Hues = Hues.bright()
+    """Named bright color variants."""
+    hl: Hues = Hues.highlights()
+    """Name highlight color variants."""
+    gs: Grayscale = Grayscale()
+    """Grayscale colors."""
+
+
+class Palette(PaletteColors, PaletteMeta):
+    """A collection of hues and bases.
+
+    The primary data structure used to render an application theme template.
+    """
+
+    _cache: dict = PrivateAttr(default={})
+    _meta: PaletteMeta | None = PrivateAttr(default=None)
+    _colors: PaletteColors | None = PrivateAttr(default=None)
+    _is_parsed: bool = PrivateAttr(default=False)
+    """Indicates the underlying colortype is ColorInfo."""
+    # TODO: We might want to make the typing here explicit.
+
+    @property
+    def meta(self) -> PaletteMeta:
+        """Palette metadata."""
+        if self._meta is None:
+            self._meta = PaletteMeta.model_validate({
+                k: v for k, v in self if not isinstance(v, ColorMap)
+            })
+        return self._meta
+
+    @property
+    def colors(self) -> PaletteColors:
+        """Palette color maps."""
+        if self._colors is None:
+            self._colors = PaletteColors.model_validate({
+                k: v for k, v in self if isinstance(v, ColorMap)
+            })
+        return self._colors
+
+    def map(self, handler: ColorFieldHandler) -> Self:
+        """Map a handler accross color fields.
+
+        Returns:
+            A new Palette instance with the handler applied to each
+            field that contains a ColorMap instance.
+
+        """
+        return self.model_validate({
+            k: v.map(handler) if isinstance(v, ColorMap) else v for k, v in self
+        })
+
+    def to(self, color_type: ColorFieldType | str) -> Self:
+        """Entry point for the `map` method that accepts a directive.
+
+        When called on an unparsed instance, a new parsed instance is created
+        and acted on.
+
+        Usage:
+            palette = palette.to("hex")
+
+        Returns:
+            A new Palette instance with the handler applied to each
+            field that contains a ColorMap instance.
+
+        """
+        inst = self if self._is_parsed else self.parse()
+        if color_type == ColorFieldType.info:
+            return inst
+        if (pal := inst._cache.get(color_type)) is None:
+            pal = self.map(Extractor(color_type))
+            inst._cache[color_type] = pal
+        return pal
+
+    def parse(self, gamut: str | None = None) -> Self:
+        """Parse each colormap.
+
+        Returns:
+            A new instance where each ColorMap field is parsed to contain
+            full ColorInfo values.
+
+        """
+        gamut = gamut or self.gamut
+        if self._is_parsed and gamut == self.gamut:
+            out = self
+        else:
+            parser = Parser(gamut=gamut)
+            out = self.map(parser)
+            out._is_parsed = True
+        return out

hadalized/templates/colors.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Color Box Example</title>
+</head>
+
+<style>
+.box {
+  display: inline-block;
+  width: 30px;
+  height: 30px;
+  border: 1px solid rgba(0, 0, 0, .2);
+}
+</style>
+
+<ul>
+{{text}}
+</ul>

hadalized/templates/config.toml

@@ -0,0 +1,15 @@
+
+{% for pal_key, pal in context.palettes.items() -%}
+[palettes."{{pal_key}}"]
+name = "{{ pal.name }}"
+desc = "{{ pal.desc }}"
+gamut = "{{ pal.gamut }}"
+mode = "{{ pal.mode }}"
+
+{% for cmap_key, cmap in pal.colors -%}
+[palettes."{{pal_key}}"."{{cmap_key}}"]
+{% for color_name, color in cmap -%}
+"{{color_name}}" = "{{color.}}"
+{% endfor -%}
+{% endfor -%}
+{% endfor -%}

hadalized/templates/generic.txt

@@ -0,0 +1 @@
+{{data}}

hadalized/templates/item.html

@@ -0,0 +1 @@
+<li><div class="box" style="background: {css}"></div> {color_name} {css}</li>

hadalized/templates/lua_module.lua

@@ -0,0 +1,6 @@
+-- Generated from gen.py
+-- WARNING: Do not edit by hand.
+
+local M = {}
+
+return M

hadalized/templates/model_dump.json

@@ -0,0 +1 @@
+{{data.model_dump_json(indent=4)}}

hadalized/templates/neovim.lua

@@ -0,0 +1,24 @@
+-- Auto-generated by {{context.app_info}}
+-- WARNING: Do not edit by hand.
+
+-- By setting our module to nil, we clear lua's cache,
+-- which means the require ahead will *always* occur.
+--
+-- This isn't strictly required but it can be a useful trick if you are
+-- incrementally editing your config a lot and want to be sure your themes
+-- changes are being picked up without restarting neovim.
+--
+-- Note if you're working in on your theme and have :Lushify'd the buffer,
+-- your changes will be applied with or without the following line.
+--
+-- The performance impact of this call can be measured in the hundreds of
+-- *nanoseconds* and such could be considered "production safe".
+--
+
+---@type Palette
+local palette = {{context.model_dump_lua()}}
+
+
+package.loaded['hadalized'] = nil
+require('hadalized').load({palette = palette})
+

hadalized/templates/neovim_palette.lua

@@ -0,0 +1,7 @@
+-- Generated file for a neovim hadalized data in lua/hadalized/palettes/
+-- Load via require("hadalized.palettes" .. "{{name}}")
+-- WARNING: Do not edit by hand.
+
+local M = {{data}}
+
+return M

hadalized/templates/palette.html

@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Palette Colors for Palette {{context.name}}</title>
+</head>
+
+<style>
+.box {
+  display: inline-block;
+  width: 60px;
+  height: 60px;
+  border: 1px solid rgba(0, 0, 0, .2);
+}
+</style>
+
+<h1>Palette Metadata for {{context.name}}</h1>
+<ul>
+    <li>name  = {{context.name}}</li>
+    <li>desc  = {{context.desc}}</li>
+    <li>mode  = {{context.mode}}</li>
+    <li>gamut = {{context.gamut}}</li>
+</ul>
+
+<h1>Hues</h1>
+<ul>
+    {% for hue_name, code in context.hue -%}
+    <li><div class="box" style="background: {{code}}"></div> {{hue_name}}</li>
+    {% endfor %}
+</ul>
+
+<h1>Bases</h1>
+<ul>
+    {% for hue_name, code in context.base -%}
+    <li><div class="box" style="background: {{code}}"></div> {{hue_name}}</li>
+    {% endfor %}
+</ul>
+
+<h1>Highlights</h1>
+<ul>
+    {% for hue_name, code in context.hl -%}
+    <li><div class="box" style="background: {{code}}"></div> {{hue_name}}</li>
+    {% endfor %}
+</ul>
+
+<h1>Brights</h1>
+<ul>
+    {% for hue_name, code in context.bright -%}
+    <li><div class="box" style="background: {{code}}"></div> {{hue_name}}</li>
+    {% endfor %}
+</ul>

hadalized/templates/palette_info.json

@@ -0,0 +1 @@
+{{context.model_dump_json(indent=4)}}

hadalized/templates/palette_test.toml

@@ -0,0 +1,10 @@
+[palettes."{{context.name}}"]
+name  = "{{context.name}}"
+mode  = "{{context.mode}}"
+gamut = "{{context.gamut}}"
+
+
+[palettes."{{context.name}}".hue]
+{% for key, val in context.hue -%}
+"{{key}}" = "{{val}}"
+{% endfor -%}

hadalized/templates/starship-all.toml

@@ -0,0 +1,98 @@
+format = '$all'
+
+# Which is equivalent to
+format = """
+$username\
+$hostname\
+$localip\
+$shlvl\
+$singularity\
+$kubernetes\
+$directory\
+$vcsh\
+$fossil_branch\
+$fossil_metrics\
+$git_branch\
+$git_commit\
+$git_state\
+$git_metrics\
+$git_status\
+$hg_branch\
+$hg_state\
+$pijul_channel\
+$docker_context\
+$package\
+$c\
+$cmake\
+$cobol\
+$daml\
+$dart\
+$deno\
+$dotnet\
+$elixir\
+$elm\
+$erlang\
+$fennel\
+$fortran\
+$gleam\
+$golang\
+$guix_shell\
+$haskell\
+$haxe\
+$helm\
+$java\
+$julia\
+$kotlin\
+$gradle\
+$lua\
+$nim\
+$nodejs\
+$ocaml\
+$opa\
+$perl\
+$php\
+$pulumi\
+$purescript\
+$python\
+$quarto\
+$raku\
+$rlang\
+$red\
+$ruby\
+$rust\
+$scala\
+$solidity\
+$swift\
+$terraform\
+$typst\
+$vlang\
+$vagrant\
+$zig\
+$buf\
+$nix_shell\
+$conda\
+$meson\
+$spack\
+$memory_usage\
+$aws\
+$gcloud\
+$openstack\
+$azure\
+$nats\
+$direnv\
+$env_var\
+$mise\
+$crystal\
+$custom\
+$sudo\
+$cmd_duration\
+$line_break\
+$jobs\
+$battery\
+$time\
+$status\
+$os\
+$container\
+$netns\
+$shell\
+$character"""