lutopia 0.2.0__py3-none-any.whl

lutopia/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from lutopia.core import UnifiedPalette
+
+_PALETTES_DIR = Path(__file__).parent / "palettes"
+_cache: dict[str, UnifiedPalette] = {}
+_names: list[str] | None = None
+
+
+def _palette_names() -> list[str]:
+    global _names
+    if _names is None:
+        _names = sorted(p.stem for p in _PALETTES_DIR.glob("*.json"))
+    return _names
+
+
+def __getattr__(name: str) -> UnifiedPalette:
+    if name.startswith("_"):
+        raise AttributeError(name)
+    names = _palette_names()
+    if name not in names:
+        available = ", ".join(names[:8]) + ("..." if len(names) > 8 else "")
+        raise AttributeError(f"lutopia has no palette {name!r}. Available: {available}")
+    if name not in _cache:
+        from lutopia.core import UnifiedPalette
+
+        raw = (_PALETTES_DIR / f"{name}.json").read_bytes()
+        _cache[name] = UnifiedPalette(json.loads(raw))
+    return _cache[name]
+
+
+def __dir__() -> list[str]:
+    return _palette_names()
+
+
+__all__ = _palette_names()

lutopia/core.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+
+class UnifiedPalette:
+    def __init__(self, json_data: dict[str, Any]) -> None:
+        self.name: str = json_data["name"]
+        self.mode: str = json_data["interpolation"]  # "linear" or "step"
+
+        anchors: list[list] = json_data["anchors"]
+        self.domain: np.ndarray = np.array([a[0] for a in anchors], dtype=float)
+        self.colors: np.ndarray = np.array([a[1] for a in anchors], dtype=float) / 255.0
+
+        kind = "linear" if self.mode == "linear" else "nearest"
+        self._evaluator: interp1d = interp1d(
+            self.domain,
+            self.colors,
+            axis=0,
+            kind=kind,
+            bounds_error=False,
+            fill_value=(self.colors[0], self.colors[-1]),
+        )
+
+    def sample(self, steps: int = 256) -> np.ndarray:
+        """Evaluate the continuous function at N evenly distributed steps."""
+        target_domain = np.linspace(self.domain[0], self.domain[-1], steps)
+        return np.clip(self._evaluator(target_domain), 0.0, 1.0)
+
+    def to_hex_list(self, steps: int = 256) -> list[str]:
+        """Return hex color strings for N samples."""
+        rgb = np.round(self.sample(steps) * 255).astype(np.uint8)
+        return [f"#{r:02x}{g:02x}{b:02x}" for r, g, b in rgb]
+
+    # --- NATIVE CONSUMER SHAPING PROPERTIES (no third-party imports) ---
+
+    @property
+    def matplotlib(self) -> np.ndarray:
+        """Normalized (256, 3) float array for ListedColormap."""
+        return self.sample(256)
+
+    @property
+    def plt(self) -> np.ndarray:
+        return self.matplotlib
+
+    @property
+    def mpl(self) -> np.ndarray:
+        return self.matplotlib
+
+    @property
+    def seaborn(self) -> list[str]:
+        """List of 256 hex strings for Seaborn palette/cmap signatures."""
+        return self.to_hex_list(256)
+
+    @property
+    def sns(self) -> list[str]:
+        return self.seaborn
+
+    @property
+    def plotly(self) -> list[list]:
+        """Plotly colorscale: [[fraction, hex], ...] over 256 steps."""
+        hex_list = self.to_hex_list(256)
+        n = len(hex_list)
+        return [[i / (n - 1), hex_list[i]] for i in range(n)]

lutopia/palettes/accent.json

@@ -0,0 +1,70 @@
+{
+  "name": "accent",
+  "interpolation": "step",
+  "anchors": [
+    [
+      0,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      1,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      2,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      3,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      4,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      5,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      6,
+      [
+        127,
+        201,
+        127
+      ]
+    ],
+    [
+      7,
+      [
+        127,
+        201,
+        127
+      ]
+    ]
+  ]
+}

lutopia/palettes/afmhot.json

@@ -0,0 +1,46 @@
+{
+  "name": "afmhot",
+  "interpolation": "linear",
+  "anchors": [
+    [
+      0.0,
+      [
+        0,
+        0,
+        0
+      ]
+    ],
+    [
+      0.25098,
+      [
+        128,
+        0,
+        0
+      ]
+    ],
+    [
+      0.498039,
+      [
+        254,
+        126,
+        0
+      ]
+    ],
+    [
+      0.74902,
+      [
+        255,
+        254,
+        127
+      ]
+    ],
+    [
+      1.0,
+      [
+        255,
+        255,
+        255
+      ]
+    ]
+  ]
+}

lutopia/palettes/autumn.json

@@ -0,0 +1,22 @@
+{
+  "name": "autumn",
+  "interpolation": "linear",
+  "anchors": [
+    [
+      0.0,
+      [
+        255,
+        0,
+        0
+      ]
+    ],
+    [
+      1.0,
+      [
+        255,
+        255,
+        0
+      ]
+    ]
+  ]
+}