kaxe 1.5.2.dev0__tar.gz → 1.5.2.dev1__tar.gz

{kaxe-1.5.2.dev0/src/kaxe.egg-info → kaxe-1.5.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kaxe
-Version: 1.5.2.dev0
+Version: 1.5.2.dev1
 Summary: A small graphing tool for functions, points, equations and more
 Author-email: Valter Yde Daugberg <valteryde@hotmail.com>
 Project-URL: Homepage, https://github.com/valteryde/kaxe

{kaxe-1.5.2.dev0 → kaxe-1.5.2.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kaxe"
-version = "1.5.2.dev0"
+version = "1.5.2.dev1"
 authors = [
   { name="Valter Yde Daugberg", email="valteryde@hotmail.com" },
 ]

{kaxe-1.5.2.dev0 → kaxe-1.5.2.dev1}/src/kaxe/__init__.py

@@ -42,6 +42,7 @@ from .core import symbol
 from .core import Colormaps, SingleColormap, Colormap, to_rgba
 from .core.window import Window, AttrObject, AttrMap, setSetting
 from .core import Axis
+from .project import save_project, load_project
 
 try:
     ipy_str = str(type(get_ipython()))

{kaxe-1.5.2.dev0 → kaxe-1.5.2.dev1}/src/kaxe/core/window.py

@@ -585,7 +585,7 @@ class Window(AttrObject):
 
 
     # save and show    
-    def save(self, fname:Union[str, BytesIO], format:Optional[str]=None):
+    def save(self, fname:Union[str, BytesIO], format:Optional[str]=None, *, project:Optional[str]=None):
         """
         Save the current window image to a file.
         
@@ -598,6 +598,8 @@ class Window(AttrObject):
             The filename where the image will be saved or a BytesIO object to save the image in memory.
         format : str, optional
             Output format: ``"png"``, ``"svg"``, or ``"pdf"``. Inferred from ``fname`` extension when omitted.
+        project : str, optional
+            If given, also write a ``.kaxe`` JSON project file to this path (editable figure source).
         
         Examples
         --------
@@ -607,6 +609,10 @@ class Window(AttrObject):
 
         """
 
+        if project is not None:
+            from ..project import save_project
+            save_project(self, project)
+
         fmt = infer_format(fname, format)
 
         if fmt == "png" and self.__bakedImage__:

{kaxe-1.5.2.dev0 → kaxe-1.5.2.dev1}/src/kaxe/plot/d3/plot3d.py

@@ -493,7 +493,11 @@ class Plot3D(Plot3DAxesMixin, Window):
         return self.__make_overlay__()
 
 
-    def save(self, fname: Union[str, BytesIO], format: Optional[str] = None):
+    def save(self, fname: Union[str, BytesIO], format: Optional[str] = None, *, project: Optional[str] = None):
+        if project is not None:
+            raise NotImplementedError(
+                "3D plot project files are not supported in .kaxe v1"
+            )
 
         self.setAttr('guiWidth', self.getAttr('width'))
         self.setAttr('guiHeight', self.getAttr('height'))

{kaxe-1.5.2.dev0 → kaxe-1.5.2.dev1}/src/kaxe/plot/grid.py

@@ -438,7 +438,11 @@ class Grid(AttrObject):
             self.grid[i].append(plot)
 
     
-    def save(self, fname: Union[str, BytesIO], format: Optional[str] = None):
+    def save(self, fname: Union[str, BytesIO], format: Optional[str] = None, *, project: Optional[str] = None):
+        if project is not None:
+            raise NotImplementedError(
+                "Grid project files are not supported in .kaxe v1 (planned for a future release)"
+            )
         fmt = infer_format(fname, format)
 
         if fmt == "svg":

kaxe-1.5.2.dev1/src/kaxe/project/__init__.py

@@ -0,0 +1,35 @@
+"""Kaxe project file (.kaxe) save/load."""
+
+from __future__ import annotations
+
+from typing import Union
+from pathlib import Path
+
+from ..core.styles import resetColor
+from . import serializers as _serializers  # noqa: F401 — register type handlers
+from .document import ProjectDocument
+from .window import assert_project_supported
+
+
+def save_project(window, path: Union[str, Path]) -> None:
+    """
+    Save a plot window to a ``.kaxe`` JSON project file.
+
+    The file stores styles, titles, numeric data, and sampled curves so the
+    figure can be reopened and edited without the original script.
+    """
+    assert_project_supported(window)
+    ProjectDocument.from_window(window).write(path)
+
+
+def load_project(path: Union[str, Path]):
+    """
+    Load a plot window from a ``.kaxe`` project file.
+
+    Returns a fresh, unbaked window ready for ``style()``, ``title()``, and ``save()``.
+    """
+    resetColor()
+    return ProjectDocument.read(path).to_window()
+
+
+__all__ = ["save_project", "load_project", "ProjectDocument"]

kaxe-1.5.2.dev1/src/kaxe/project/codec.py

@@ -0,0 +1,136 @@
+"""JSON-safe encoding helpers for Kaxe project files."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ..core.color import Colormap, Colormaps, to_rgba
+from ..core.styles import ComputedAttribute
+
+
+def encode_color(value) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, Colormap):
+        return encode_colormap(value)
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple)):
+        if value and isinstance(value[0], (list, tuple)):
+            return [list(to_rgba(c)) for c in value]
+        return list(to_rgba(value))
+    return list(to_rgba(value))
+
+
+def encode_colormap(cmap: Colormap) -> dict:
+    for name in (
+        "standard", "green", "brown", "blue", "yellow", "cream",
+        "red", "rainbow", "purple", "orange",
+    ):
+        preset = getattr(Colormaps, name, None)
+        if preset is cmap:
+            return {"preset": name}
+    steps = []
+    for step in cmap.colorGradientSteps:
+        steps.append(list(int(round(c)) for c in step))
+    return {"gradient": steps}
+
+
+def decode_colormap(data: Optional[dict]) -> Colormap:
+    if not data:
+        return Colormaps.standard
+    if "preset" in data:
+        name = data["preset"]
+        preset = getattr(Colormaps, name, None)
+        if preset is None:
+            raise ValueError(f"Unknown colormap preset: {name!r}")
+        return preset
+    if "gradient" in data:
+        return Colormap(data["gradient"])
+    raise ValueError(f"Invalid colormap payload: {data!r}")
+
+
+def encode_attrmap_styles(attrs: dict) -> dict:
+    """Serialize user style overrides only."""
+    out = {}
+    for scope, values in attrs.items():
+        if not values:
+            continue
+        scope_out = {}
+        for key, val in values.items():
+            if isinstance(val, ComputedAttribute):
+                continue
+            if key == "color" or key.endswith("Color"):
+                scope_out[key] = encode_color(val)
+            else:
+                scope_out[key] = _encode_value(val)
+        if scope_out:
+            out[scope] = scope_out
+    return out
+
+
+def apply_attrmap_styles(attrmap, styles: dict) -> None:
+    for scope, values in (styles or {}).items():
+        for key, val in values.items():
+            if scope == "global":
+                attrmap.setAttr(key, _decode_value(val))
+            else:
+                attrmap.setAttr(key, _decode_value(val), obj=scope)
+
+
+def _encode_value(val: Any) -> Any:
+    if isinstance(val, (list, tuple)):
+        return [_encode_value(v) for v in val]
+    if isinstance(val, Colormap):
+        return encode_colormap(val)
+    return val
+
+
+def _decode_value(val: Any) -> Any:
+    if isinstance(val, dict) and ("preset" in val or "gradient" in val):
+        return decode_colormap(val)
+    if isinstance(val, list) and val and isinstance(val[0], list):
+        return [tuple(to_rgba(c)) for c in val]
+    if isinstance(val, list) and len(val) in (3, 4) and all(isinstance(c, (int, float)) for c in val):
+        return to_rgba(val)
+    return val
+
+
+def encode_legend(obj) -> Optional[dict]:
+    text = getattr(obj, "legendText", None)
+    if text is None:
+        return None
+    sym = getattr(obj, "legendSymbol", None)
+    sym_name = sym if isinstance(sym, str) else None
+    color = getattr(obj, "legendColor", None)
+    return {
+        "text": text,
+        "symbol": sym_name,
+        "color": encode_color(color) if color is not None else None,
+    }
+
+
+def apply_legend(obj, data: Optional[dict]) -> None:
+    if not data:
+        return
+    if hasattr(obj, "legend"):
+        kwargs = {}
+        if data.get("symbol"):
+            kwargs["symbol"] = data["symbol"]
+        if data.get("color") is not None:
+            kwargs["color"] = data["color"]
+        obj.legend(data["text"], **kwargs)
+    else:
+        obj.legendText = data["text"]
+        if data.get("symbol"):
+            obj.legendSymbol = data["symbol"]
+        if data.get("color") is not None:
+            obj.legendColor = to_rgba(data["color"])
+
+
+def encode_list(values) -> list:
+    return [float(v) for v in values]
+
+
+def encode_grid(data) -> list:
+    return [[float(cell) for cell in row] for row in data]

kaxe-1.5.2.dev1/src/kaxe/project/context.py

@@ -0,0 +1,24 @@
+"""Export/import context for project serialization."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass
+class ExportContext:
+    window: Any
+    sample_count: int = 2000
+
+    def plot_identity(self) -> Optional[str]:
+        return getattr(self.window, "identity", None)
+
+    def plot_window_axis(self):
+        return getattr(self.window, "windowAxis", None)
+
+
+@dataclass
+class ImportContext:
+    """Placeholder for future blob deduplication and path resolution."""
+    pass

kaxe-1.5.2.dev1/src/kaxe/project/document.py

@@ -0,0 +1,47 @@
+"""Kaxe project document (.kaxe JSON) encode/decode."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Union
+
+from .context import ImportContext
+from .window import build_document, import_window
+
+KAXE_VERSION = 1
+
+
+class ProjectDocument:
+    def __init__(self, data: dict):
+        self.data = data
+
+    @classmethod
+    def from_window(cls, window) -> "ProjectDocument":
+        payload = build_document(window)
+        payload["kaxe_version"] = KAXE_VERSION
+        return cls(payload)
+
+    def to_window(self):
+        version = self.data.get("kaxe_version", 1)
+        if version != KAXE_VERSION:
+            raise ValueError(
+                f"Unsupported kaxe_version {version} (this Kaxe supports version {KAXE_VERSION})"
+            )
+        return import_window(self.data, ImportContext())
+
+    def encode(self, indent: int = 2) -> str:
+        return json.dumps(self.data, indent=indent, ensure_ascii=False)
+
+    @classmethod
+    def decode(cls, text: str) -> "ProjectDocument":
+        return cls(json.loads(text))
+
+    def write(self, path: Union[str, Path]) -> None:
+        path = Path(path)
+        path.write_text(self.encode(), encoding="utf-8")
+
+    @classmethod
+    def read(cls, path: Union[str, Path]) -> "ProjectDocument":
+        path = Path(path)
+        return cls.decode(path.read_text(encoding="utf-8"))

kaxe-1.5.2.dev1/src/kaxe/project/registry.py

@@ -0,0 +1,33 @@
+"""Type registry for project export/import."""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, Optional, Tuple
+
+_EXPORTERS: Dict[str, Callable] = {}
+_IMPORTERS: Dict[str, Callable] = {}
+
+
+def register_type(type_name: str, export_fn: Callable, import_fn: Callable) -> None:
+    _EXPORTERS[type_name] = export_fn
+    _IMPORTERS[type_name] = import_fn
+
+
+def export_object(obj, ctx) -> dict:
+    type_name = type(obj).__name__
+    if type_name in _EXPORTERS:
+        return _EXPORTERS[type_name](obj, ctx)
+    raise TypeError(
+        f"Object type {type_name!r} cannot be exported to a .kaxe project (v1)"
+    )
+
+
+def import_object(data: dict, ctx):
+    type_name = data.get("type")
+    if not type_name or type_name not in _IMPORTERS:
+        raise ValueError(f"Unknown or missing object type in project: {type_name!r}")
+    return _IMPORTERS[type_name](data, ctx)
+
+
+def has_exporter(type_name: str) -> bool:
+    return type_name in _EXPORTERS

kaxe-1.5.2.dev1/src/kaxe/project/sample.py

@@ -0,0 +1,72 @@
+"""Sample callable curves for project export."""
+
+from __future__ import annotations
+
+import math
+from typing import Callable, List, Optional, Sequence, Tuple
+
+import numpy as np
+
+from ..core.bounds import (
+    DEFAULT_DOMAIN_1D,
+    resolve_interval,
+)
+from ..core.helper import isRealNumber
+from ..plot import identities
+
+
+def sample_curve(
+    f: Callable,
+    *,
+    domain: Optional[Sequence[float]],
+    window_axis,
+    plot_identity: Optional[str],
+    first_axis_log: bool = False,
+    n: int = 2000,
+    args: tuple = (),
+    kwargs: dict = None,
+) -> Tuple[List[float], List[float]]:
+    """
+    Sample f(x) on a uniform grid for project storage.
+
+    Returns parallel x, y lists (finite points only).
+    """
+    kwargs = kwargs or {}
+    wa = list(window_axis or [None, None, None, None])
+    while len(wa) < 4:
+        wa.append(None)
+
+    default_x = (0.01, 10.0) if first_axis_log else DEFAULT_DOMAIN_1D
+    x0, x1 = resolve_interval(domain, wa[0], wa[1], default_x)
+    if first_axis_log and x0 <= 0:
+        x0 = 0.01
+    if x0 == x1:
+        x0 -= 0.5
+        x1 += 0.5
+
+    xs = np.linspace(x0, x1, n)
+    x_out, y_out = [], []
+
+    if plot_identity == identities.POLAR:
+        fidelity = max(n, 360)
+        for angle_deg in range(0, 360 * 100, max(1, 360 * 100 // fidelity)):
+            angle = math.radians(angle_deg / 100.0)
+            try:
+                r = f(angle, *args, **kwargs)
+            except Exception:
+                continue
+            if isRealNumber(r):
+                x_out.append(float(angle))
+                y_out.append(float(r))
+        return x_out, y_out
+
+    for x in xs:
+        try:
+            y = f(float(x), *args, **kwargs)
+        except Exception:
+            continue
+        if isRealNumber(y) and math.isfinite(float(y)):
+            x_out.append(float(x))
+            y_out.append(float(y))
+
+    return x_out, y_out

kaxe-1.5.2.dev1/src/kaxe/project/sampled_curve.py

@@ -0,0 +1,82 @@
+"""Curve from stored x/y samples (reload of exported Function2D)."""
+
+from __future__ import annotations
+
+from ..core.shapes import shapes
+from ..core.helper import isRealNumber
+from ..plot import identities
+
+
+class SampledCurve2D:
+    """Line curve from project file samples; preserves line style metadata."""
+
+    def __init__(
+        self,
+        x,
+        y,
+        color,
+        thickness=10,
+        dotted=0,
+        dashed=0,
+    ):
+        self.x = list(x)
+        self.y = list(y)
+        self.color = color
+        self.thickness = thickness
+        self.dotted = dotted
+        self.dashed = dashed
+        self.batch = shapes.Batch()
+        self.supports = [identities.XYPLOT, identities.POLAR, identities.LOGPLOT]
+        self.legendColor = color
+
+    def finalize(self, parent):
+        self.lineSegments = [[]]
+        last = None
+        for x, y in zip(self.x, self.y):
+            if not (isRealNumber(x) and isRealNumber(y)):
+                continue
+            px, py = parent.pixel(x, y)
+            if not px or not py:
+                continue
+            pt = parent.clamp(px, py)
+            if last is None:
+                last = [px, py]
+                continue
+            if parent.inside(px, py) or parent.inside(*last):
+                self.lineSegments[-1].append(parent.clamp(last[0], last[1]))
+                self.lineSegments[-1].append(pt)
+            else:
+                self.lineSegments.append([])
+            last = [px, py]
+
+        scale = getattr(parent, "getVisualScale", lambda: 1.0)()
+        width = max(1, int(self.thickness * scale))
+        for segment in self.lineSegments:
+            if len(segment) < 2:
+                continue
+            shapes.LineSegment(
+                segment,
+                color=self.color,
+                width=width,
+                batch=self.batch,
+                dotted=self.dotted > 0,
+                dashed=self.dashed > 0,
+                dashedDist=self.dashed,
+                dottedDist=self.dotted,
+            )
+
+    def draw(self, *args, **kwargs):
+        self.batch.draw(*args, **kwargs)
+
+    def push(self, *args, **kwargs):
+        self.batch.push(*args, **kwargs)
+
+    def legend(self, text, symbol=None, color=None):
+        from ..core.symbol import symbol as symbols
+
+        self.legendText = text
+        self.legendSymbol = symbol if symbol else symbols.LINE
+        if color is not None:
+            from ..core.color import to_rgba
+            self.legendColor = to_rgba(color)
+        return self