monobiome 1.3.1__py3-none-any.whl

monobiome/__init__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("monobiome")

monobiome/__main__.py

@@ -0,0 +1,19 @@
+from monobiome.cli import create_parser, configure_logging
+
+
+def main() -> None:
+    parser = create_parser()
+    args = parser.parse_args()
+
+    # skim off log level to handle higher-level option
+    if hasattr(args, "log_level") and args.log_level is not None:
+        configure_logging(args.log_level)
+
+    if "func" in args:
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

monobiome/cli/__init__.py

@@ -0,0 +1,32 @@
+import logging
+import argparse
+
+from monobiome.cli import scheme, palette
+
+logger: logging.Logger = logging.getLogger(__name__)
+
+def configure_logging(log_level: int) -> None:
+    """
+    Configure logger's logging level.
+    """
+
+    logger.setLevel(log_level)
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Accent modeling CLI",
+    )
+    parser.add_argument(
+        "--log-level",
+        type=int,
+        metavar="int",
+        choices=[10, 20, 30, 40, 50],
+        help="Log level: 10=DEBUG, 20=INFO, 30=WARNING, 40=ERROR, 50=CRITICAL",
+    )
+
+    subparsers = parser.add_subparsers(help="subcommand help")
+
+    palette.register_parser(subparsers)
+    scheme.register_parser(subparsers)
+
+    return parser

monobiome/cli/palette.py

@@ -0,0 +1,51 @@
+import argparse
+from pathlib import Path
+
+from monobiome.util import _SubparserType
+from monobiome.palette import generate_palette
+
+
+def register_parser(subparsers: _SubparserType) -> None:
+    parser = subparsers.add_parser(
+        "palette",
+        help="generate primary palette"
+    )
+
+    parser.add_argument(
+        "-n",
+        "--notation",
+        type=str,
+        default="hex",
+        choices=["hex", "oklch"],
+        help="Color notation to export (either hex or oklch)",
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        type=str,
+        default="toml",
+        choices=["json", "toml"],
+        help="Format of palette file (either JSON or TOML)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file to write palette content",
+    )
+
+    parser.set_defaults(func=handle_palette)
+
+
+def handle_palette(args: argparse.Namespace) -> None:
+    notation = args.notation
+    file_format = args.format
+    output = args.output
+
+    palette_text = generate_palette(notation, file_format)
+
+    if output is None:
+        print(palette_text)
+    else:
+        with Path(output).open("w") as f:
+            f.write(palette_text)

monobiome/cli/scheme.py

@@ -0,0 +1,155 @@
+import argparse
+from pathlib import Path
+
+from monobiome.util import _SubparserType
+from monobiome.scheme import generate_scheme
+from monobiome.constants import monotone_h_map
+
+
+def register_parser(subparsers: _SubparserType) -> None:
+    parser = subparsers.add_parser(
+        "scheme",
+        help="create scheme variants"
+    )
+
+    parser.add_argument(
+        "mode",
+        type=str,
+        choices=["dark", "light"],
+        help="Scheme mode (light or dark)"
+    )
+    parser.add_argument(
+        "biome",
+        type=str,
+        choices=list(monotone_h_map.keys()),
+        help="Biome setting for scheme."
+    )
+    parser.add_argument(
+        "-m",
+        "--metric",
+        type=str,
+        default="oklch",
+        choices=["wcag", "oklch", "lightness"],
+        help="Metric to use for measuring swatch distances."
+    )
+
+    # e.g., wcag=4.5; oklch=0.40; lightness=40
+    parser.add_argument(
+        "-d",
+        "--distance",
+        type=float,
+        default=0.40,
+        help="Distance threshold for specified metric",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        help="Output file to write scheme content",
+    )
+
+    # these params remain rooted in lightness; no need to accommodate metric
+    # given these are monotone adjustments. You *could* consider rooting these
+    # in metric units, but along monotones, distance=lightness and WCAG isn't a
+    # particularly good measure of perceptual distinction, so we'd prefer the
+    # former.
+    parser.add_argument(
+        "-l",
+        "--l-base",
+        type=int,
+        default=20,
+        help="Minimum lightness level (default: 20)",
+    )
+    parser.add_argument(
+        "--l-step",
+        type=int,
+        default=5,
+        help="Lightness step size (default: 5)",
+    )
+
+    # gaps
+    parser.add_argument(
+        "--fg-gap",
+        type=int,
+        default=50,
+        help="Foreground lightness gap (default: 50)",
+    )
+    parser.add_argument(
+        "--grey-gap",
+        type=int,
+        default=30,
+        help="Grey lightness gap (default: 30)",
+    )
+    parser.add_argument(
+        "--term-fg-gap",
+        type=int,
+        default=65,
+        help="Terminal foreground lightness gap (default: 60)",
+    )
+
+    parser.set_defaults(func=handle_scheme)
+
+
+def handle_scheme(args: argparse.Namespace) -> None:
+    output = args.output
+
+    mode = args.mode
+    biome =  args.biome
+    metric = args.metric
+    distance = args.distance
+    l_base = args.l_base
+    l_step = args.l_step
+    fg_gap = args.fg_gap
+    grey_gap = args.grey_gap
+    term_fg_gap = args.term_fg_gap
+
+    full_color_map = {
+        "red": "red",
+        "orange": "orange",
+        "yellow": "yellow",
+        "green": "green",
+        "cyan": "cyan",
+        "blue": "blue",
+        "violet": "violet",
+        "magenta": "orange",
+    }
+    term_color_map = {
+        "red": "red",
+        "yellow": "yellow",
+        "green": "green",
+        "cyan": "blue",
+        "blue": "blue",
+        "magenta": "orange",
+    }
+    vim_color_map = {
+        "red": "red",
+        "orange": "orange",
+        "yellow": "yellow",
+        "green": "green",
+        "cyan": "green",
+        "blue": "blue",
+        "violet": "blue",
+        "magenta": "red",
+    }
+    # vim_color_map = full_color_map
+
+    scheme_text = generate_scheme(
+        mode,
+        biome,
+        metric,
+        distance,
+        l_base,
+        l_step,
+        fg_gap,
+        grey_gap,
+        term_fg_gap,
+        full_color_map,
+        term_color_map,
+        vim_color_map,
+    )
+
+    if output is None:
+        print(scheme_text)
+    else:
+        with Path(output).open("w") as f:
+            f.write(scheme_text)

monobiome/constants.py

@@ -0,0 +1,123 @@
+import tomllib
+from importlib.resources import files
+
+import numpy as np
+
+from monobiome.curve import (
+    l_maxC_h,
+    bezier_y_at_x,
+)
+
+parameters_file = files("monobiome.data") / "parameters.toml"
+parameters = tomllib.load(parameters_file.open("rb"))
+
+L_min: int = parameters.get("L_min", 10)
+L_max: int = parameters.get("L_max", 98)
+L_step: int = parameters.get("L_step", 5)
+
+L_points: list[int] = list(range(L_min, L_max+1))
+
+# L-space just affects accuracy of chroma max
+L_space = np.arange(0, 100 + L_step, L_step)
+
+monotone_C_map = parameters.get("monotone_C_map", {})
+h_weights = parameters.get("h_weights", {})
+h_L_offsets = parameters.get("h_L_offsets", {})
+h_C_offsets = parameters.get("h_C_offsets", {})
+monotone_h_map = parameters.get("monotone_h_map", {})
+accent_h_map = parameters.get("accent_h_map", {})
+h_map = {**monotone_h_map, **accent_h_map}
+
+"""
+Compute chroma maxima at provided lightness levels across hues.
+
+A map with max chroma values for each hue across lightness space
+
+{
+   "red": [ Cmax@L=10, Cmax@L=11, Cmax@L=12, ... ],
+   "orange": [ Cmax@L=10, Cmax@L=11, Cmax@L=12, ... ],
+   ...
+}
+"""
+Lspace_Cmax_Hmap = {
+    h_str: [l_maxC_h(_L, _h) for _L in L_space]
+    for h_str, _h in h_map.items()
+}
+
+
+"""
+Set QBR curves, *unbounded* chroma curves for all hues
+
+1. Raw bezier chroma values for each hue across the lightness space
+
+   Lpoints_Cqbr_Hmap = {
+      "red": [ Bezier@L=10, Bezier@L=11, Bezier@L=12, ... ],
+      ...
+   }
+
+2. Three bezier control points for each hue's chroma curve
+
+   QBR_ctrl_Hmap = {
+      "red": np.array([
+          [ x1, y1 ],
+          [ x2, y2 ],
+          [ x3, y3 ]
+       ]),
+      ...
+   }
+"""
+Lpoints_Cqbr_Hmap = {}
+QBR_ctrl_Hmap = {}
+
+for h_str, _h in monotone_h_map.items():
+    Lpoints_Cqbr_Hmap[h_str] = np.array(
+        [monotone_C_map[h_str]]*len(L_points)
+    )
+    
+for h_str, _h in accent_h_map.items():
+    Lspace_Cmax = Lspace_Cmax_Hmap[h_str]
+    
+    # get L value of max chroma; will be a bezier control
+    L_Cmax_idx = np.argmax(Lspace_Cmax)
+    L_Cmax = L_space[L_Cmax_idx]
+
+    # offset control point by any preset x-shift
+    L_Cmax += h_L_offsets[h_str]
+
+    # and get max C at the L offset
+    Cmax = l_maxC_h(L_Cmax, _h)
+
+    # set 3 control points; shift by any global linear offest
+    C_offset = h_C_offsets.get(h_str, 0)
+    
+    p_0 = np.array([0, 0])
+    p_Cmax = np.array([L_Cmax, Cmax + C_offset])
+    p_100 = np.array([100, 0])
+    
+    B_L_points = bezier_y_at_x(
+        p_0, p_Cmax, p_100,
+        h_weights.get(h_str, 1),
+        L_points
+    )
+    Lpoints_Cqbr_Hmap[h_str] = B_L_points
+    QBR_ctrl_Hmap[h_str] = np.vstack([p_0, p_Cmax, p_100])
+
+
+"""
+Bezier chroma values, but bounded to attainable gamut colors (bezier fit
+can produce invalid chroma values)
+
+h_L_points_Cstar = {
+   "red": [ bounded-bezier@L=10, bounded-bezier@L=11, ... ],
+   ...
+}
+"""
+Lpoints_Cstar_Hmap = {}
+
+for h_str, L_points_C in Lpoints_Cqbr_Hmap.items():
+    _h = h_map[h_str]
+
+    Lpoints_Cstar_Hmap[h_str] = [
+        max(0, min(_C, l_maxC_h(_L, _h)))
+        for _L, _C in zip(L_points, L_points_C, strict=True)
+    ]

monobiome/curve.py

@@ -0,0 +1,77 @@
+from functools import cache
+
+import numpy as np
+from coloraide import Color
+
+
+def quad_bezier_rational(
+    P0: float,
+    P1: float,
+    P2: float,
+    w: float,
+    t: np.array,
+) -> np.array:
+    """
+    Compute the point values of a quadratic rational Bezier curve.
+
+    Uses `P0`, `P1`, and `P2` as the three control points of the curve. `w`
+    controls the weight toward the middle control point ("sharpness" of the
+    curve"), and `t` is the number of sample points used along the curve.
+    """
+
+    t = np.asarray(t)[:, None]
+    num = (1-t)**2*P0 + 2*w*(1-t)*t*P1 + t**2*P2
+    den = (1-t)**2 + 2*w*(1-t)*t + t**2
+    
+    return num / den
+    
+def bezier_y_at_x(
+    P0: float,
+    P1: float,
+    P2: float,
+    w: float,
+    x: float,
+    n: int = 400,
+) -> np.array:
+    """
+    For the provided QBR parameters, provide the curve value at the given
+    input.
+    """
+
+    t = np.linspace(0, 1, n)
+    B = quad_bezier_rational(P0, P1, P2, w, t)
+    x_vals, y_vals = B[:, 0], B[:, 1]
+    
+    return np.interp(x, x_vals, y_vals)
+
+@cache
+def l_maxC_h(
+    _l: float,
+    _h: float,
+    space: str = 'srgb',
+    eps: float = 1e-6,
+    tol: float = 1e-9
+) -> float:
+    """
+    Binary search for max attainable OKLCH chroma at fixed lightness and hue.
+
+    Parameters:
+        _l: lightness
+        _h: hue
+
+    Returns:
+        Max in-gamut chroma at provided lightness and hue
+    """
+
+    def chroma_in_gamut(_c: float) -> bool:
+        color = Color('oklch', [_l/100, _c, _h])
+        return color.convert(space).in_gamut(tolerance=tol)
+
+    lo, hi = 0.0, 0.1
+    while chroma_in_gamut(hi):
+        hi *= 2
+    while hi - lo > eps:
+        m = (lo + hi) / 2
+        lo, hi = (m, hi) if chroma_in_gamut(m) else (lo, m)
+
+    return lo

monobiome/data/parameters.toml

@@ -0,0 +1,65 @@
+L_min = 10
+L_max = 98
+L_step = 5
+
+[monotone_C_map]
+alpine = 0
+badlands = 0.011
+chaparral = 0.011
+savanna = 0.011
+grassland = 0.011
+reef = 0.011
+tundra = 0.011
+heathland = 0.011
+moorland = 0.011
+
+[h_weights]
+red = 3.0
+orange = 3.8
+yellow = 3.8
+green = 3.8
+cyan = 3.8
+blue = 3.6
+violet = 3.0
+magenta = 3.6
+
+[h_L_offsets]
+red = 0
+orange = -5.5
+yellow = -13.5
+green = -12.5
+cyan = -10.5
+blue = 9
+violet = 7
+magenta = 2
+
+[h_C_offsets] 
+red = 0
+orange = -0.015
+yellow = -0.052
+green = -0.08
+cyan = -0.009
+blue = -0.01
+violet = -0.047
+magenta = -0.1
+
+[monotone_h_map]
+alpine = 0
+badlands = 29
+chaparral = 62.5
+savanna = 104
+grassland = 148
+reef = 205
+tundra = 262
+heathland = 306
+moorland = 350
+
+[accent_h_map]
+red = 29
+orange = 62.5
+yellow = 104
+green = 148
+cyan = 205
+blue = 262
+violet = 306
+magenta = 350

monobiome/palette.py

@@ -0,0 +1,54 @@
+import json
+from functools import cache
+from importlib.metadata import version
+
+from coloraide import Color
+
+from monobiome.constants import (
+    h_map,
+    L_points,
+    Lpoints_Cstar_Hmap,
+)
+
+
+@cache
+def compute_hlc_map(notation: str) -> dict[str, dict[int, str]]:
+    hlc_map = {}
+
+    for h_str, Lpoints_Cstar in Lpoints_Cstar_Hmap.items():
+        _h = h_map[h_str]
+        hlc_map[h_str] = {}
+        
+        for _l, _c in zip(L_points, Lpoints_Cstar, strict=True):
+            oklch = Color('oklch', [_l/100, _c, _h])
+
+            if notation == "hex":
+                srgb = oklch.convert('srgb')
+                c_str = srgb.to_string(hex=True)
+            elif notation == "oklch":
+                ol, oc, oh = oklch.convert('oklch').coords()
+                c_str = f"oklch({ol*100:.1f}% {oc:.4f} {oh:.1f})"
+            
+            hlc_map[h_str][_l] = c_str
+
+    return hlc_map
+
+def generate_palette(
+    notation: str,
+    file_format: str,
+) -> str:
+    mb_version = version("monobiome")
+    hlc_map = compute_hlc_map(notation)
+            
+    if file_format == "json":
+        hlc_map["version"] = mb_version
+        return json.dumps(hlc_map, indent=4)
+    else:
+        toml_lines = [f"version = {mb_version}", ""]
+        for _h, _lc_map in hlc_map.items():
+            toml_lines.append(f"[{_h}]")
+            for _l, _c in _lc_map.items():
+                toml_lines.append(f'l{_l} = "{_c}"')
+            toml_lines.append("")
+
+        return "\n".join(toml_lines)

monobiome/plotting.py

@@ -0,0 +1,176 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from monobiome.constants import (
+    h_map,
+    L_space,
+    L_points,
+    accent_h_map,
+    monotone_h_map,
+    Lspace_Cmax_Hmap,
+    Lpoints_Cstar_Hmap,
+)
+
+
+def plot_hue_chroma_bounds() -> None:
+    name_h_map = {}
+    ax_h_map = {}
+    fig, axes = plt.subplots(
+        len(monotone_h_map),
+        1,
+        sharex=True,
+        sharey=True,
+        figsize=(4, 10)
+    )
+
+    for i, h_str in enumerate(Lpoints_Cstar_Hmap):
+        _h = h_map[h_str]
+
+        l_space_Cmax = Lspace_Cmax_Hmap[h_str]
+        l_points_Cstar = Lpoints_Cstar_Hmap[h_str]
+        
+        if _h not in ax_h_map:
+            ax_h_map[_h] = axes[i]
+        ax = ax_h_map[_h]
+        
+        if _h not in name_h_map:
+            name_h_map[_h] = []
+        name_h_map[_h].append(h_str)
+
+        # plot Cmax and Cstar
+        ax.plot(L_space, l_space_Cmax, c="g", alpha=0.3, label="Cmax")
+        
+        cstar_label = f"{'accent' if h_str in accent_h_map else 'monotone'} C*"
+        ax.plot(L_points, l_points_Cstar, alpha=0.7, label=cstar_label)
+        
+        ax.title.set_text(f"Hue [${_h}$] - {'|'.join(name_h_map[_h])}")
+        
+    axes[-1].set_xlabel("Lightness (%)")
+    axes[-1].set_xticks([L_points[0], L_points[-1]])
+
+    fig.tight_layout()
+    fig.subplots_adjust(top=0.9)
+
+    handles, labels = axes[-1].get_legend_handles_labels()
+    unique = dict(zip(labels, handles))
+    fig.legend(unique.values(), unique.keys(), loc='lower center', bbox_to_anchor=(0.5, -0.06), ncol=3)
+
+    plt.suptitle("$C^*$ curves for hue groups")
+    plt.show()
+
+
+def plot_hue_chroma_star() -> None:
+    fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+
+    # uncomment to preview 5 core term colors
+    colors = accent_h_map.keys()
+    #colors = set(["red", "orange", "yellow", "green", "blue"])
+
+    for h_str in Lpoints_Cstar_Hmap:
+        if h_str not in accent_h_map or h_str not in colors:
+            continue
+        ax.fill_between(
+            L_points,
+            Lpoints_Cstar_Hmap[h_str],
+            alpha=0.2,
+            color='grey',
+            label=h_str
+        )
+
+        x, y = L_points, Lpoints_Cstar_Hmap[h_str]
+        n = int(0.45*len(x))
+        ax.text(x[n], y[n]-0.01, h_str, rotation=10, va='center', ha='left')
+        
+    ax.set_xlabel("Lightness (%)")
+    ax.set_xticks([L_points[0], 45, 50, 55, 60, 65, 70, L_points[-1]])
+    plt.suptitle("$C^*$ curves (v1.4.0)")
+    fig.show()
+
+
+def palette_image(palette, cell_size=40, keys=None):
+    if keys is None:
+        names = list(palette.keys())
+    else:
+        names = keys
+        
+    row_count = len(names)
+    col_counts = [len(palette[n]) for n in names]
+    max_cols = max(col_counts)
+
+    h = row_count * cell_size
+    w = max_cols * cell_size
+    img = np.ones((h, w, 3), float)
+
+    lightness_keys_per_row = []
+
+    for r, name in enumerate(names):
+        shades = palette[name]
+        keys = sorted(shades.keys())
+        lightness_keys_per_row.append(keys)
+        for c, k in enumerate(keys):
+            col = Color(shades[k]).convert("srgb").fit(method="clip")
+            rgb = [col["r"], col["g"], col["b"]]
+            r0, r1 = r * cell_size, (r + 1) * cell_size
+            c0, c1 = c * cell_size, (c + 1) * cell_size
+            img[r0:r1, c0:c1, :] = rgb
+
+    return img, names, lightness_keys_per_row, cell_size, max_cols
+
+
+def show_palette(palette, cell_size=40, keys=None):
+    img, names, keys, cell_size, max_cols = palette_image(palette, cell_size, keys=keys)
+
+    fig_w = img.shape[1] / 100
+    fig_h = img.shape[0] / 100
+    fig, ax = plt.subplots(figsize=(fig_w, fig_h))
+
+    ax.imshow(img, interpolation="none", origin="upper")
+    ax.set_xticks([])
+
+    ytick_pos = [(i + 0.5) * cell_size for i in range(len(names))]
+    ax.set_yticks(ytick_pos)
+    ax.set_yticklabels(names)
+
+    ax.set_ylim(img.shape[0], 0)   # ensures rows render correctly without half-cells
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    from monobiome.constants import OKLCH_hL_dict
+
+    keys = [
+        "alpine",
+        "badlands",
+        "chaparral",
+        "savanna",
+        "grassland",
+        "reef",
+        "tundra",
+        "heathland",
+        "moorland",
+        "orange",
+        "yellow",
+        "green",
+        "cyan",
+        "blue",
+        "violet",
+        "magenta",
+        "red",
+    ]
+    term_keys = [
+        "alpine",
+        "badlands",
+        "chaparral",
+        "savanna",
+        "grassland",
+        "tundra",
+        "red",
+        "orange",
+        "yellow",
+        "green",
+        "blue",
+    ]
+
+    show_palette(OKLCH_hL_dict, cell_size=25, keys=keys)
+    # show_palette(OKLCH_hL_dict, cell_size=1, keys=term_keys)

monobiome/scheme.py

@@ -0,0 +1,254 @@
+from functools import cache
+from collections.abc import Callable
+
+from coloraide import Color
+
+from monobiome.util import oklch_distance
+from monobiome.palette import compute_hlc_map
+from monobiome.constants import (
+    accent_h_map,
+    monotone_h_map,
+)
+
+
+@cache
+def compute_dma_map(
+    dT: float,
+    metric: Callable | None = None
+) -> dict[str, dict]:
+    """
+    For threshold `dT`, compute the nearest accent shades that exceed that
+    threshold for every monotone shade.
+
+    Returns: map of minimum constraint satisfying accent colors for monotone
+        spectra
+
+        {
+            "alpine": {
+                "oklch( ... )": {
+                    "red": *nearest oklch >= dT from M base*,
+                    ...
+                },
+                ...
+            },
+            ...
+        }
+    """
+
+    if metric is None:
+        metric = oklch_distance
+    
+    oklch_hlc_map = compute_hlc_map("oklch")
+    oklch_color_map = {
+        c_name: [Color(c_str) for c_str in c_str_dict.values()]
+        for c_name, c_str_dict in oklch_hlc_map.items()
+    }
+    
+    dT_mL_acol_map = {}
+    for m_name in monotone_h_map:
+        mL_acol_map = {}
+        m_colors = oklch_color_map[m_name]
+        
+        for m_color in m_colors:
+            acol_min_map = {}
+            
+            for a_name in accent_h_map:
+                a_colors = oklch_color_map[a_name]
+                oklch_dists = filter(
+                    lambda d: (d[1] - dT) >= 0,
+                    [
+                        (ac, metric(m_color, ac))
+                        for ac in a_colors
+                    ]
+                )
+                oklch_dists = list(oklch_dists)
+                if oklch_dists:
+                    min_a_color = min(oklch_dists, key=lambda t: t[1])[0]
+                    acol_min_map[a_name] = min_a_color
+    
+            # make sure the current monotone level has *all* accents; o/w
+            # ignore
+            if len(acol_min_map) < len(accent_h_map):
+                continue
+
+            mL = m_color.coords()[0]
+            mL_acol_map[int(mL*100)] = acol_min_map
+        dT_mL_acol_map[m_name] = mL_acol_map
+
+    return dT_mL_acol_map
+
+def generate_scheme_groups(
+    mode: str,
+    biome: str,
+    metric: str,
+    distance: float,
+    l_base: int,
+    l_step: int,
+    fg_gap: int,
+    grey_gap: int,
+    term_fg_gap: int,
+    accent_color_map: dict[str, str],
+) -> tuple[dict[str, str], ...]:
+    """
+    Parameters:
+        mode: one of ["dark", "light"]
+        biome: biome setting
+        metric: one of ["wcag", "oklch", "lightness"]
+    """
+
+    metric_map = {
+        "wcag": lambda mc,ac: ac.contrast(mc, method='wcag21'),
+        "oklch": oklch_distance,
+        "lightness": lambda mc,ac: abs(mc.coords()[0]-ac.coords()[0])*100,
+    }
+    
+    metric_func = metric_map[metric]
+    dT_mL_acol_map = compute_dma_map(distance, metric=metric_func)
+    Lma_map = {
+        m_name: mL_acol_dict[l_base]
+        for m_name, mL_acol_dict in dT_mL_acol_map.items()
+        if l_base in mL_acol_dict
+    }
+    
+    # the `mL_acol_dict` only includes lightnesses where all accent colors were
+    # within threshold. Coverage here will be partial if, at the `mL`, there is
+    # some monotone base that doesn't have all accents within threshold. This
+    # can happen at the edge, e.g., alpine@L15 has all accents w/in the
+    # distance, but the red accent was too far under tundra@L15, so there's no
+    # entry. This particular case is fairly rare; it's more likely that *all*
+    # monotones are undefined. Either way, both such cases lead to partial
+    # scheme coverage.
+    if len(Lma_map) < len(monotone_h_map):
+        print(f"Warning: partial scheme coverage for {l_base=}@{distance=}")
+    if biome not in Lma_map:
+        print(f"Biome {biome} unable to meet {metric} constraints")
+    accent_colors = Lma_map.get(biome, {})
+    
+    meta_pairs = [
+        ("mode", mode),
+        ("biome", biome),
+        ("metric", metric),
+        ("distance", distance),
+        ("l_base", l_base),
+        ("l_step", l_step),
+        ("fg_gap", fg_gap),
+        ("grey_gap", grey_gap),
+        ("term_fg_gap", term_fg_gap),
+    ]
+
+    # note how selection_bg steps up by `l_step`, selection_fg steps down by
+    # `l_step` (from their respective bases)
+    term_pairs = [
+        ("background", f"f{{{{{biome}.l{l_base}}}}}"),
+        ("selection_bg", f"f{{{{{biome}.l{l_base+l_step}}}}}"),
+        ("selection_fg", f"f{{{{{biome}.l{l_base+term_fg_gap-l_step}}}}}"),
+        ("foreground", f"f{{{{{biome}.l{l_base+term_fg_gap}}}}}"),
+        ("cursor", f"f{{{{{biome}.l{l_base+term_fg_gap-l_step}}}}}"),
+        ("cursor_text", f"f{{{{{biome}.l{l_base+l_step}}}}}"),
+    ]
+
+    monotone_pairs = []
+    monotone_pairs += [
+        (f"bg{i}", f"f{{{{{biome}.l{l_base+i*l_step}}}}}")
+        for i in range(4)
+    ]
+    monotone_pairs += [
+        (f"fg{3-i}", f"f{{{{{biome}.l{fg_gap+l_base+i*l_step}}}}}")
+        for i in range(4)
+    ]
+ 
+    accent_pairs = [
+        ("black", f"f{{{{{biome}.l{l_base}}}}}"),
+        ("grey", f"f{{{{{biome}.l{l_base+grey_gap}}}}}"),
+        ("white", f"f{{{{{biome}.l{l_base+term_fg_gap-2*l_step}}}}}"),
+    ]
+    for color_name, mb_accent in accent_color_map.items():
+        aL = int(100*accent_colors[mb_accent].coords()[0])
+        accent_pairs.append(
+            (
+                color_name,
+                f"f{{{{{mb_accent}.l{aL}}}}}"
+            )
+        )
+    
+    return meta_pairs, term_pairs, monotone_pairs, accent_pairs
+
+def generate_scheme(
+    mode: str,
+    biome: str,
+    metric: str,
+    distance: float,
+    l_base: int,
+    l_step: int,
+    fg_gap: int,
+    grey_gap: int,
+    term_fg_gap: int,
+    full_color_map: dict[str, str],
+    term_color_map: dict[str, str],
+    vim_color_map: dict[str, str],
+) -> str:
+    l_sys = l_base
+    l_app = l_base + l_step
+
+    term_bright_offset = 10
+
+    # negate gaps if mode is light
+    if mode == "light":
+        l_step *= -1
+        fg_gap *= -1
+        grey_gap *= -1
+        term_fg_gap *= -1
+        term_bright_offset *= -1
+
+    meta, _, mt, ac = generate_scheme_groups(
+        mode, biome, metric, distance,
+        l_sys, l_step,
+        fg_gap, grey_gap, term_fg_gap,
+        full_color_map
+    )
+
+    _, term, _, term_norm_ac = generate_scheme_groups(
+        mode, biome, metric, distance,
+        l_app, l_step,
+        fg_gap, grey_gap, term_fg_gap,
+        term_color_map
+    )
+    _, _, _, term_bright_ac = generate_scheme_groups(
+        mode, biome, metric, distance,
+        l_app + term_bright_offset, l_step,
+        fg_gap, grey_gap, term_fg_gap,
+        term_color_map
+    )
+
+    _, _, vim_mt, vim_ac = generate_scheme_groups(
+        mode, biome, metric, distance,
+        l_app, l_step,
+        fg_gap, grey_gap, term_fg_gap,
+        vim_color_map
+    )
+
+    def pair_strings(pair_list: list[tuple[str, str]]) -> list[str]:
+        return [
+            f"{lhs:<12} = \"{rhs}\""
+            for lhs, rhs in pair_list
+        ]
+
+    scheme_pairs = []
+    scheme_pairs += pair_strings(meta)
+    scheme_pairs += pair_strings(mt)
+    scheme_pairs += pair_strings(ac)
+
+    scheme_pairs += ["", "[term]"]
+    scheme_pairs += pair_strings(term)
+
+    scheme_pairs += ["", "[term.normal]"]
+    scheme_pairs += pair_strings(term_norm_ac)
+
+    scheme_pairs += ["", "[term.bright]"]
+    scheme_pairs += pair_strings(term_bright_ac)
+
+    scheme_pairs += ["", "[vim]"]
+    scheme_pairs += pair_strings(vim_mt)
+    scheme_pairs += pair_strings(vim_ac)
+
+    return "\n".join(scheme_pairs)

monobiome/util.py

@@ -0,0 +1,35 @@
+import math
+from types import GenericAlias
+from argparse import ArgumentParser, _SubParsersAction
+
+from coloraide import Color
+
+_SubParsersAction.__class_getitem__ = classmethod(GenericAlias)
+_SubparserType = _SubParsersAction[ArgumentParser]
+
+def oklch_distance(xc: Color, yc: Color) -> float:
+    """
+    Compute the distance between two colors in OKLCH space.
+
+    Note: `xc` and `yc` are presumed to be OKLCH colors already, such that
+    `.coords()` yields an `(l, c, h)` triple directly rather than first
+    requiring conversion. When we can make this assumption, we save roughly an
+    order of magnitude in runtime.
+
+    1. `xc.distance(yc, space="oklch")`: 500k evals takes ~2s
+    2. This method: 500k evals takes ~0.2s
+    """
+
+    l1, c1, h1 = xc.coords()
+    l2, c2, h2 = yc.coords()
+
+    rad1 = h1 / 180 * math.pi
+    rad2 = h2 / 180 * math.pi
+    x1, y1 = c1 * math.cos(rad1), c1 * math.sin(rad1)
+    x2, y2 = c2 * math.cos(rad2), c2 * math.sin(rad2)
+    
+    dx = x1 - x2
+    dy = y1 - y2
+    dz = l1 - l2
+    
+    return (dx**2 + dy**2 + dz**2)**0.5

monobiome-1.3.1.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: monobiome
+Version: 1.3.1
+Summary: Monobiome color palette
+Project-URL: Homepage, https://doc.olog.io/monobiome
+Project-URL: Documentation, https://doc.olog.io/monobiome
+Project-URL: Repository, https://git.olog.io/olog/monobiome
+Project-URL: Issues, https://git.olog.io/olog/monobiome/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: coloraide>=5.1
+Requires-Dist: imageio[ffmpeg]>=2.37.2
+Requires-Dist: ipython>=9.6.0
+Requires-Dist: kaleido>=1.1.0
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: numpy>=2.3.4
+Requires-Dist: pillow>=12.0.0
+Requires-Dist: plotly>=6.3.1
+Requires-Dist: scipy>=1.16.2
+
+# Monobiome
+`monobiome` is a minimal, balanced color palette for use in terminals and text
+editors. It was designed in OKLCH space to achieve perceptual uniformity across
+all hues at various levels of luminance, and does so for _five_ monotone bases
+and _five_ accent colors (plus one gray "default"). Each of the monotone base
+colors (named according to a natural biome whose colors they loosely resemble)
+are designed to achieve identical contrast with the accents, and thus any one
+of the options can be selected to change the feeling of the palette without
+sacrificing readability.
+
+![Theme preview](images/repo_preview_four_split.png)
+_(Preview of default light and dark theme variants)_
+
+See screenshots for the full set of theme variants in [THEMES](THEMES.md) (also
+discussed below).
+
+The name "monobiome" connects the palette to its two key sources of
+inspiration:
+
+- `mono-`: `monobiome` is inspired by the [`monoindustrial` theme][1], and
+  attempts to extend and balance its accents while retaining similar color
+  identities.
+- `-biome`: the desire for several distinct monotone options entailed finding a
+  way to ground the subtle color variations that were needed, and I liked the
+  idea of tying the choices to naturally occurring environmental variation like
+  Earth's biomes (even if it is a very loose affiliation, e.g., green-ish =
+  grass, basically).
+
+## Palette
+The `monobiome` palette consists of four monotone bases and five accent colors,
+each of which is anchored by hue and spread uniformly across lightness levels
+15 to 95 (in OKLCH space). 
+
+![Diagram of palette accents and monotones](images/palette.png)
+
+The chroma curve for each accent is carefully designed to vary smoothly across
+the lightness spectrum, with the goal of retaining strong color identity in all
+settings. Additionally, as alluded to above, the (WCAG 2) contrast ratio
+between any choice of monotone background at a given lightness level and the
+accent colors is virtually identical ($\pm 0.1$). Put another way, the relative
+contrast between accents depends only on the _lightness_ of the background
+monotone, not its hue. *(Note that this is not generally the case; at a fixed
+lightness level, the contrast between two colors depends on their hue.)*
+
+## Concrete themes
+
+![Split view of Alpine and Tundra biomes](images/theme-split-view.png)
+
+*(Light and dark theme splits of Alpine and Tundra biomes)*
+
+Themes are derived from the `monobiome` palette by varying both the monotone
+hue (the "biome") and the extent of the background/foreground lightness (the
+"harshness"). This is done for both light and dark schemes, and in each case
+accent colors are selected at a lightness level that ensures each meet a
+minimum contrast relative to the primary background. The following diagram
+shows each of the 36 resulting combinations:
+
+![Diagram of the 36 available concrete theme options](images/themes.png)
+
+The "soft" harshness level uses monotone shades closer to the mid-shade
+(lightness level 55), whereas "hard" harshness uses shades further from it.
+Once the biome and harshness level are chosen, we're left with a bounded
+monotone range over which common theme elements can be defined. For example,
+the following demonstrates how background and foreground elements are chosen
+for the `monobiome` Vim themes:
+
+![
+  Diagram depicting how themes colors are selected by harshness and mapped onto
+  application-specific elements
+](images/vim_theme_elements.png)
+
+Note how theme elements are mapped onto the general identifiers `bg0-bg3` for
+backgrounds, `fg0-fg3` for foregrounds, and `gray` for a central gray tone. The
+relative properties (lightness differences, contrast ratios) between colors
+assigned to these identifiers are preserved regardless of biome or harshness
+(e.g., `bg3` and `gray` are _always_ separated by 20 lightness points in any
+theme). As a result, applying `monobiome` themes to specific applications can
+effectively boil down to defining a single "relative template" that uses these
+identifiers, after which any of the 36 theme options can applied immediately.
+
+Read more about how themes are created in [DESIGN](DESIGN.md).
+
+# Usage
+This repo provides the 36 theme files for `kitty`, `vim`/`neovim`, and `fzf` in
+the `app-config/` directory. You can also find raw palette colors in
+`colors/monobiome.toml` if you want to use them to define themes for other
+applications.
+
+Each of the files in the `app-config/` directory are named according to
+
+```sh
+<harshness>-<biome>-monobiome-<mode>.<ext>
+```
+
+For example, `monobiome-tundra-dark-soft.vim` is the Vim theme file for the
+dark `tundra` variant with the soft harshness level.
+
+## Applications
+- `kitty`
+
+  Find `kitty` themes in `app-config/kitty`. Themes can be activated in your
+  `kitty.conf` with
+  
+  ```sh
+  include <theme-file>
+  ```
+
+  Themes are generated using the [`kitty` theme
+  template](templates/apps/kitty/templates/active.theme).
+
+- `vim`/`neovim`
+
+  Find `vim`/`neovim` themes in `app-config/nvim`. Themes can be activated by placing a
+  theme file on Vim's runtime path and setting it in your `.vimrc`/`init.vim`
+  with
+  
+  ```sh
+  colorscheme <theme-name>
+  ```
+
+  Themes are generated using the [`vim` theme
+  template](templates/apps/nvim/templates/theme.vim).
+
+- `fzf`
+
+  In `app-config/fzf`, you can find scripts that can be ran to export FZF theme
+  variables. In your shell config (e.g., `.bashrc` or `.zshrc`), you can source
+  these files to apply them in your terminal:
+  
+  ```sh
+  source <theme-file>
+  ```
+
+  Themes are generated using the [`fzf` theme
+  template](templates/apps/fzf/templates/active.theme).
+
+- Firefox
+
+  Firefox themes for all monotone backgrounds are publicly listed as [Mozilla
+  add-ons][2], and switch between light/dark schemes based on system settings.
+  You can also download raw XPI files for each theme in `app-config/firefox/`,
+  each of which is generated using the [Firefox `manifest.json`
+  template](templates/apps/firefox/templates/none-dark.manifest.json).
+
+  Static [light][4] and [dark][5] are additionally available.
+
+  ![Firefox theme previews](images/firefox/themes.png)
+
+# Switching themes
+[`symconf`][3] is a general-purpose application config manager that can be used
+to generate all `monobiome` variants from a single palette file, and set themes
+for all apps at once. You can find example theme templates in
+`templates/groups/theme`, which provide general theme variables you can use in
+your own config templates.
+
+For instance, in an app like `kitty`, you can define a template like
+
+```conf
+# base settings
+background           f{{theme.term.background}}
+foreground           f{{theme.term.foreground}}
+
+selection_background f{{theme.term.selection_bg}}
+selection_foreground f{{theme.term.selection_fg}}
+
+cursor               f{{theme.term.cursor}}
+cursor_text_color    f{{theme.term.cursor_text_color}}
+
+# black
+color0               f{{theme.term.normal.black}}
+color8               f{{theme.term.bright.black}}
+
+# red
+color1               f{{theme.term.normal.red}}
+color9               f{{theme.term.bright.red}}
+
+# green
+color2               f{{theme.term.normal.green}}
+color10              f{{theme.term.bright.green}}
+
+# yellow
+color3               f{{theme.term.normal.yellow}}
+color11              f{{theme.term.bright.yellow}}
+
+# blue
+color4               f{{theme.term.normal.blue}}
+color12              f{{theme.term.bright.blue}}
+
+# purple (red)
+color5               f{{theme.term.normal.purple}}
+color13              f{{theme.term.bright.purple}}
+
+# cyan (blue)
+color6               f{{theme.term.normal.cyan}}
+color14              f{{theme.term.bright.cyan}}
+
+## white
+color7               f{{theme.term.normal.white}}
+color15              f{{theme.term.bright.white}}
+```
+
+and use `symconf` to dynamically fill these variables based on a selected
+biome/harshness/mode. This can be done for any app config file.
+
+
+[1]: https://github.com/isa/TextMate-Themes/blob/master/monoindustrial.tmTheme
+[2]: https://addons.mozilla.org/en-US/firefox/collections/18495484/monobiome/
+[3]: https://github.com/ologio/symconf
+[4]: https://addons.mozilla.org/en-US/firefox/collections/18495484/monobiome-light/
+[5]: https://addons.mozilla.org/en-US/firefox/collections/18495484/monobiome-dark/

monobiome-1.3.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+monobiome/__init__.py,sha256=ChC5YFLK0kgvi0MJwD68LtZgUMJVCtNbtY32UQTvdA4,75
+monobiome/__main__.py,sha256=k2Pu_FeAsW_wnE55Y-JJaRP_GgxAZEjW3z_Kmk3O8C8,431
+monobiome/constants.py,sha256=w4H9V2Tp2ZK3ddcjtBdDtokZdj2Y1ssW3RSopxqP7rw,3105
+monobiome/curve.py,sha256=tw44OoRGDSxTzljxJkgifWhCTEj05TBYnw4jOdrNgfA,1748
+monobiome/palette.py,sha256=fReZD1Aa7xOKQQgnYB8qRxszZy1nq9XLqjUIblENsvI,1489
+monobiome/plotting.py,sha256=1eAJY-0PLtq2r4ZHYCY3YYnVlCVu7PXteAcs1zV4irY,4679
+monobiome/scheme.py,sha256=CFP_WqTk-CwbgpVt2E_TczC9cZymAh_lqbkWmN4AsOg,7541
+monobiome/util.py,sha256=qHLC-azOgslJcW1tNNX5TVeG3RPGpleUO2s9Nu1rbjY,1068
+monobiome/cli/__init__.py,sha256=wtBhzdyyRy0-WM4fUpDESJBiedYy8MbwousVCdangUE,774
+monobiome/cli/palette.py,sha256=i3baWZs4Sverbd79YMBPYnH0P2rT0i7z3ZAtO_UBWNw,1219
+monobiome/cli/scheme.py,sha256=CkwtGBCPUEPt2TnK_WDQBg8TKTw_hjGoQtbjjBlNmH0,3725
+monobiome/data/parameters.toml,sha256=7ru0j_1G5rNFWc7AFKSHJUpyL_I2qdZYeDFt6q5wtQw,801
+monobiome-1.3.1.dist-info/METADATA,sha256=n_gLP_F0ghbpq3eco0ULz37Lmc1GnhFhsIPgHGnhNn0,8947
+monobiome-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+monobiome-1.3.1.dist-info/entry_points.txt,sha256=LpqkPxdTacTY_TaRn8eczICmPbVlXdRSoMqaxSfVxh4,54
+monobiome-1.3.1.dist-info/top_level.txt,sha256=ZA2wgRkPoG4xG0rSjyHKkuG8cdSHRr1U_DcrplXoi3A,10
+monobiome-1.3.1.dist-info/RECORD,,

monobiome-1.3.1.dist-info/WHEEL

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

monobiome-1.3.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+monobiome = monobiome.__main__:main

monobiome-1.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+monobiome