Theme¶

@classmethod
def from_json(cls, document: Mapping[str, object]) -> "Tokens":
    """Reads the tokens from theme.json's document."""
    colors = {str(scheme): {name: str(value) for name, value in section(document, scheme).items()} for scheme in Scheme}
    metrics = {name: float(cast("float", value)) for name, value in section(document, Section.METRICS).items()}
    fonts = {name: str(value) for name, value in section(document, Section.FONTS).items()}

    return cls(colors=colors, metrics=metrics, fonts=fonts)

@classmethod
def from_tokens(cls, tokens: Tokens) -> "Metrics":
    """Reads the metrics from the tokens, which name each field in kebab case."""
    return cls(**{field.name: tokens.metrics[field.name.replace("_", "-")] for field in fields(cls)})

@classmethod
def from_tokens(cls, tokens: Tokens, *, dark: bool) -> "Palette":
    """The palette of one scheme of the tokens."""
    colors = tokens.colors[Scheme.DARK if dark else Scheme.LIGHT]

    return cls(
        paper=colors[Token.BACKGROUND],
        plot=colors[Token.CARD],
        text=colors[Token.FOREGROUND],
        grid=colors[Token.BORDER],
        accent=colors[Token.PRIMARY],
        muted=colors[Token.MUTED_FOREGROUND],
        chart=tuple(colors[token] for token in CHART_TOKENS),
        dark=dark,
        metrics=Metrics.from_tokens(tokens),
        font=tokens.fonts[Font.SANS],
        mono=tokens.fonts[Font.MONO],
    )

@classmethod
def load(cls, *, dark: bool = True) -> "Palette":
    """The dist's palette in one scheme."""
    return cls.from_tokens(load_tokens(), dark=dark)

@classmethod
def with_accent(cls, accent: str, *, dark: bool = True) -> "Palette":
    """The dist's palette with an accent of the caller's own."""
    return replace(cls.load(dark=dark), accent=accent)

def colorway(self, count: int = 6) -> list[str]:
    """The chart colours, then hues rotated evenly from the accent for the rest."""
    listed = list(self.chart[:count])
    extra = count - len(listed)

    return [*listed, *(rotate_hue(self.accent, (i + 1) / (extra + 1)) for i in range(extra))]

def tones(self) -> Tones:
    """The derived interaction colours: a raised surface and text that reads on the accent."""
    on_accent = self.paper if luminance(self.accent) >= DARK_BELOW else self.text

    return Tones(raised=mix(self.text, self.paper, 0.12), on_accent=hex_color(on_accent))

def plotly_template(self, base: str | None = None) -> Json:
    """The base template (plotly_dark or plotly_white by scheme) repainted in this palette, at the label size, with the top margin a titleless figure needs."""
    template = template_json(base or ("plotly_dark" if self.dark else "plotly_white"))
    layout = section(template, "layout")
    axis_paint = {"gridcolor": self.grid, "zerolinecolor": self.grid, "linecolor": self.grid}
    repainted: Json = {
        **layout,
        "paper_bgcolor": self.paper,
        "plot_bgcolor": self.plot,
        "font": {**section(layout, "font"), "color": self.text, "family": self.font, "size": self.metrics.size_label},
        "colorway": self.colorway(),
        "margin": {**section(layout, "margin"), "t": TITLELESS_TOP_MARGIN},
        "xaxis": {**section(layout, "xaxis"), **axis_paint},
        "yaxis": {**section(layout, "yaxis"), **axis_paint},
    }

    return {**template, "layout": repainted}

def install(self) -> None:
    """Registers this palette's plotly template as the default, so every figure built afterwards is painted in it."""
    pio.templates[TEMPLATE] = self.plotly_template()  # pyright: ignore[reportUnknownMemberType]  # plotly's template registry ships no stub
    pio.templates.default = TEMPLATE  # pyright: ignore[reportUnknownMemberType]

def xterm_theme(self) -> dict[str, str]:
    """The xterm ITheme colours."""
    return {"background": self.paper, "foreground": self.text, "cursor": self.accent, "selectionBackground": self.tones().raised}