kplot 1.1.6__tar.gz → 1.1.8__tar.gz

{kplot-1.1.6 → kplot-1.1.8}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.3
 Name: kplot
-Version: 1.1.6
+Version: 1.1.8
 Summary: a matplotlib wrapper for keyan :-)
+Author: Keyan Gootkin
+Author-email: Keyan Gootkin <keyangootkin@gmail.com>
 Requires-Dist: kbasic>=0.1.4
 Requires-Dist: matplotlib>=3.10.8
 Requires-Dist: numpy>=2.4.2

{kplot-1.1.6 → kplot-1.1.8}/pyproject.toml

@@ -1,8 +1,11 @@
 [project]
 name = "kplot"
-version = "1.1.6"
+version = "1.1.8"
 description = "a matplotlib wrapper for keyan :-)"
 readme = "README.md"
+authors = [
+  { name="Keyan Gootkin", email="keyangootkin@gmail.com" },
+]
 requires-python = ">=3.11"
 dependencies = [
     "kbasic>=0.1.4",

{kplot-1.1.6 → kplot-1.1.8}/src/kplot/cmaps.py

@@ -1,20 +1,23 @@
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                             Imports                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-from kbasic.array import tile
-from functools import wraps
-from glob import glob
-import matplotlib.pyplot as plt
+from kbasic.typing import Number, Iterable
 from matplotlib.pyplot import cm
-from matplotlib.colors import Colormap, LinearSegmentedColormap, ListedColormap, hex2color, Normalize, LogNorm, FuncNorm, AsinhNorm, PowerNorm, SymLogNorm, BoundaryNorm, CenteredNorm, TwoSlopeNorm
-from mpl_toolkits.axes_grid1 import make_axes_locatable
-import numpy as np
+from matplotlib.colors import Colormap, LinearSegmentedColormap, ListedColormap, \
+        hex2color, Normalize, LogNorm, FuncNorm, AsinhNorm, PowerNorm, SymLogNorm, \
+        BoundaryNorm, CenteredNorm, TwoSlopeNorm 
+from numpy import uint8, zeros, ndarray, inf, nanmin, nanmax, nanquantile, nanmean, \
+        nanstd, absolute, log10, ones, linspace
+from colorist import ColorOKLCH
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                              Types                              <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 class Norm:
-    types: list = [Normalize, LogNorm, FuncNorm, AsinhNorm, PowerNorm, SymLogNorm, BoundaryNorm, CenteredNorm, TwoSlopeNorm]
+    types: list = [
+        Normalize, LogNorm, FuncNorm, AsinhNorm, PowerNorm, SymLogNorm, 
+        BoundaryNorm, CenteredNorm, TwoSlopeNorm
+    ]
 class Cmap:
     types: list = [Colormap, ListedColormap, LinearSegmentedColormap]
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
@@ -30,7 +33,7 @@ manoaskies_centered = LinearSegmentedColormap.from_list("manoaskies_centered", [
 manoaskies_background_blue = "#0C0524"
 pink2grey = LinearSegmentedColormap.from_list("p2g", [pink, shadow])
 grey2black = LinearSegmentedColormap.from_list("g2b", [shadow, "#000000"])
-colors_list = np.zeros((256, 4))
+colors_list = zeros((256, 4))
 colors_list[:128] =  list(hex2color(manoaskies_background_blue))+[1]
 for i in range(28): colors_list[128+i] = pink2grey(i/28)
 for i in range(100): colors_list[156+i] = grey2black(i/150)
@@ -40,10 +43,9 @@ default_cmap = cm.plasma
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                            Functions                            <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# # Ploting utils
 def auto_norm(
     norm: str, 
-    frames: np.ndarray, 
+    frames: ndarray, 
     linear_threshold: float|None = None, 
     center: float|None = None, 
     saturate: float|None = None
@@ -52,7 +54,7 @@ def auto_norm(
 
     Args:
         norm (str): what type of scale to use, e.g. lognorm or centerednorm
-        frames (np.ndarray): the images to base the normalization on
+        frames (ndarray): the images to base the normalization on
         linear_threshold (float | None, optional): for symlognorm. Defaults to None.
         center (float | None, optional): for centered normalizations. Defaults to None.
         saturate (float | None, optional): the level at which to saturate the norm, e.g. if saturate=0.01 then the 
@@ -61,38 +63,67 @@ def auto_norm(
     Returns:
         matplotlib normalization
     """
-    frames = frames[(-np.inf < frames)&(frames < np.inf)]
+    frames = frames[(-inf < frames)&(frames < inf)]
     # set min/max IF saturate is None                          or IF saturate is a tuple                                          ELSE assume its a float
-    low = np.nanmin(frames) if saturate is None else np.nanquantile(frames, 1-saturate[0]) if isinstance(saturate, tuple) else np.nanquantile(frames, 1-saturate)
-    high = np.nanmax(frames) if saturate is None else np.nanquantile(frames, 0+saturate[1]) if isinstance(saturate, tuple) else np.nanquantile(frames, 0+saturate)
+    low = nanmin(frames) if saturate is None else nanquantile(frames, 1-saturate[0]) if isinstance(saturate, tuple) else nanquantile(frames, 1-saturate)
+    high = nanmax(frames) if saturate is None else nanquantile(frames, 0+saturate[1]) if isinstance(saturate, tuple) else nanquantile(frames, 0+saturate)
     match norm.lower():
         case "lognorm"|"log":
             if low < 0: raise ValueError(f"minimum is {low}, LogNorm only takes positive values")
-            if low==0: low=np.nanmin(frames[frames!=0])
+            if low==0: low=nanmin(frames[frames!=0])
             return LogNorm(vmin=low, vmax=high)
         case "symlognorm"|"symlog"|"sym":
-            sig = np.nanstd(frames)
-            mu = np.nanmean(frames)
-            if np.abs(mu)-sig > 0: raise TypeError("SymLogNorm is only designed for stuff close to zero!")
+            sig = nanstd(frames)
+            mu = nanmean(frames)
+            if absolute(mu)-sig > 0: raise TypeError("SymLogNorm is only designed for stuff close to zero!")
             return SymLogNorm(sig if linear_threshold is None else linear_threshold, vmin=low, vmax=high)
         case n if n in ["centerednorm", "twoslope", "twoslopenorm"]:
-            sig = np.nanstd(frames)
-            mu = np.nanmean(frames)
+            sig = nanstd(frames)
+            mu = nanmean(frames)
             # for the center use center if give otherwise use 0 if mean is small, else use mean
-            vcenter = center if not center is None else 0 if np.abs(mu)-sig > 0 else mu
+            vcenter = center if not center is None else 0 if absolute(mu)-sig > 0 else mu
             return TwoSlopeNorm(vmin=low, vcenter=vcenter, vmax=high)
         case _: return Normalize(vmin=low, vmax=high)
-def align_algorithm(x: list|np.ndarray, mode: str):
+def align_algorithm(x: list|ndarray, mode: str):
     match mode:
         case 'mid'|'m'|'center'|'c':
             return [(x[i] + x[i+1])/2 for i in range(len(x)-1)]
         case 'logmid'|'lm':
-            return [np.log10((10**x[i] + 10**x[i+1])/ 2) for i in range(len(x)-1)]
+            return [log10((10**x[i] + 10**x[i+1])/ 2) for i in range(len(x)-1)]
         case 'left'|'l':
             return x[:-1]
         case 'right'|'r':
             return x[1:]
+def oklch_cmap(
+    luminosity: float|Iterable[float] = 0.5,
+    chroma: float|Iterable[float] = 0.4,
+    hue: float|Iterable[float] = (90, 270),
+) -> ListedColormap:
+    ls = ones(256) * luminosity if type(luminosity) in Number.types else linspace(*luminosity, 256)
+    cs = ones(256) * chroma if type(chroma) in Number.types else linspace(*chroma, 256)
+    hs = ones(256) * hue if type(hue) in Number.types else linspace(*hue, 256)
+    return ListedColormap([
+        OKLCH(li, ci, hi).rgb for li, ci, hi in zip(ls, cs, hs)
+    ])
 
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                            Decorators                           <|===|-<
+# >-|===|>                             Classes                             <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+class OKLCH:
+    def __init__(self, lightness: float, chroma: float, hue: float, alpha: float = 1) -> None:
+        assert all(m:=[0<=lightness<=1, 0.<=chroma<=0.4, 0<=hue<360, 0<=alpha<=1]), \
+            f"invalid value given in {lightness, chroma, hue, alpha}"
+        self.lightness = lightness 
+        self.chroma = chroma 
+        self.hue = hue 
+        self.alpha = alpha 
+    @property 
+    def rgb(self) -> tuple[float]: 
+        cobj = ColorOKLCH(self.lightness, self.chroma, self.hue).convert_oklch_to_srgb()
+        return (uint8(cobj.red)/256, uint8(cobj.green)/256, uint8(cobj.blue)/256)
+    @property 
+    def rgba(self) -> tuple[float]:
+        return tuple([*self.rgb, self.alpha])
+    @property
+    def ansi(self) -> str:
+        return ColorOKLCH(self.lightness, self.chroma, self.hue).generate_ansi_code()

{kplot-1.1.6 → kplot-1.1.8}/src/kplot/movie.py

@@ -4,31 +4,28 @@
 from kplot.utils import column_width, two_column_width
 from kplot.cmaps import auto_norm
 from kplot.image import show
+from kbasic.strings import purple
 from kbasic.bar import verbose_bar
 from kbasic.parsing import ensure_path
-import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
-import numpy as np
 from os import system
 from glob import glob
 from typing import Callable
+from functools import wraps
+from numpy import ndarray, array
+from matplotlib.pyplot import subplots
+from matplotlib.figure import Figure
 
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                              Types                              <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                           Definitions                           <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                            Functions                            <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 def ffmpeg(
         file_name: str, 
         source: str = "./frames", destination: str = "./", 
-        fps: int = 30
+        fps: int = 30, verbose: bool = False,
     ) -> None:
     file_path: str = destination + '/' + file_name
     if not file_path.endswith('.mp4'): file_path += ".mp4"
+    if verbose: print(purple("FFMPeg running..."))
     system(f"ffmpeg -loglevel 8 -framerate {fps} -pattern_type glob -i '{source+'/*.png'}' -c:v libx264 -pix_fmt yuv420p -y {file_path}")
 def func_video(
         video_name: str, fig: Figure, updater: Callable, N: int, 
@@ -39,7 +36,7 @@ def func_video(
     if len(glob(f"{frames}/*.png"))>0: system(f"rm {frames}/*.png")
     ndigits = len(str(N))
     # if the size isn't divisible by 2 ffmpeg gets mad???
-    [wpix, hpix] = (np.array(fig.get_size_inches()) * dpi // 1).astype(int)
+    [wpix, hpix] = (array(fig.get_size_inches()) * dpi // 1).astype(int)
     if wpix%2==1: wpix += 1 
     if hpix%2==1: hpix += 1
     fig.set_size_inches(wpix/dpi, hpix/dpi)
@@ -57,7 +54,7 @@ def line_video(
     fps=20, dpi=100,
     **kwargs
 ):
-    if not ax: fig, ax = plt.subplots(figsize=figsize)
+    if not ax: fig, ax = subplots(figsize=figsize)
     fig = ax.get_figure()
     [line] = ax.plot(xs[0], ys[0], **kwargs)
     def update(f: int):
@@ -70,7 +67,7 @@ def lines_video(
         ax=None, figsize=(5,5),
         fps=20, dpi=100
 ) -> None:
-    if not ax: fig, ax = plt.subplots(figsize=figsize)
+    if not ax: fig, ax = subplots(figsize=figsize)
     fig = ax.get_figure()
     lines = []
     for (x, y) in data:
@@ -81,7 +78,7 @@ def lines_video(
             line.set_data(x[i], y[i])
     func_video(fname, fig, update, min([len(data[i][0]) for i in range(len(data))]), fps=fps, dpi=dpi, destination=destination, frames=frames)
 def show_video(
-    frames: np.ndarray,
+    frames: ndarray,
     fname: str,
     ax = None,
     norm = 'linear',
@@ -100,20 +97,16 @@ def show_video(
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
 # >-|===|>                            Decorators                           <|===|-<
 # !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-def line_video_function(func):
+def line_video_function(func: Callable):
     @wraps(func)
     def line_video_wrapper(*args, ax=None, save="default.gif", **kwargs):
         # Calculate data via func
         xs, ys = func(*args, **kwargs)
         line_video(xs, ys, save, ax=ax)
     return line_video_wrapper
-def show_video_function(func):
+def show_video_function(func: Callable):
     @wraps(func)
     def simple_video_wrapper(*args, save="default.gif", norm='linear', **kwargs):
         frames = func(*args, **kwargs)
         show_video(frames, save, norm=norm)
-    return simple_video_wrapper
-
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
-# >-|===|>                             Classes                             <|===|-<
-# !==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==!==
+    return simple_video_wrapper