visibility, zorder, parent/aliases

Author: ksunden

data_prototype/artist.py

@@ -1,8 +1,11 @@
+from bisect import insort
 from typing import Sequence
 
+import numpy as np
+
 from .containers import DataContainer, ArrayContainer, DataUnion
 from .description import Desc, desc_like
-from .conversion_edge import Edge, TransformEdge
+from .conversion_edge import Edge, Graph, TransformEdge
 
 
 class Artist:
@@ -16,11 +19,28 @@ def __init__(
         self._container = DataUnion(container, kwargs_cont)
 
         edges = edges or []
-        self._edges = list(edges)
-
-    def draw(self, renderer, edges: Sequence[Edge]) -> None:
+        self._visible = True
+        self._graph = Graph(edges)
+        self._clip_box: DataContainer = ArrayContainer(
+            {"x": "parent", "y": "parent"},
+            **{"x": np.asarray([0, 1]), "y": np.asarray([0, 1])}
+        )
+
+    def draw(self, renderer, graph: Graph) -> None:
         return
 
+    def set_clip_box(self, container: DataContainer) -> None:
+        self._clip_box = container
+
+    def get_clip_box(self, container: DataContainer) -> DataContainer:
+        return self._clip_box
+
+    def get_visible(self):
+        return self._visible
+
+    def set_visible(self, visible):
+        self._visible = visible
+
 
 class CompatibilityArtist:
     """A compatibility shim to ducktype as a classic Matplotlib Artist.
@@ -42,10 +62,44 @@ class CompatibilityArtist:
     def __init__(self, artist: Artist):
         self._artist = artist
 
-        self.axes = None
+        self._axes = None
         self.figure = None
         self._clippath = None
+        self._visible = True
         self.zorder = 2
+        self._graph = Graph([])
+
+    @property
+    def axes(self):
+        return self._axes
+
+    @axes.setter
+    def axes(self, ax):
+        self._axes = ax
+
+        if self._axes is None:
+            self._graph = Graph([])
+            return
+
+        desc: Desc = Desc(("N",), coordinates="data")
+        xy: dict[str, Desc] = {"x": desc, "y": desc}
+        self._graph = Graph(
+            [
+                TransformEdge(
+                    "data",
+                    xy,
+                    desc_like(xy, coordinates="axes"),
+                    transform=self._axes.transData - self._axes.transAxes,
+                ),
+                TransformEdge(
+                    "axes",
+                    desc_like(xy, coordinates="axes"),
+                    desc_like(xy, coordinates="display"),
+                    transform=self._axes.transAxes,
+                ),
+            ],
+            aliases=(("parent", "axes"),),
+        )
 
     def set_figure(self, fig):
         self.figure = fig
@@ -65,32 +119,19 @@ def set_clip_path(self, path):
     def get_animated(self):
         return False
 
-    def draw(self, renderer, edges=None):
+    def get_visible(self):
+        return self._visible
 
-        if edges is None:
-            edges = []
+    def set_visible(self, visible):
+        self._visible = visible
 
-        if self.axes is not None:
-            desc: Desc = Desc(("N",), coordinates="data")
-            xy: dict[str, Desc] = {"x": desc, "y": desc}
-            edges.append(
-                TransformEdge(
-                    "data",
-                    xy,
-                    desc_like(xy, coordinates="axes"),
-                    transform=self.axes.transData - self.axes.transAxes,
-                )
-            )
-            edges.append(
-                TransformEdge(
-                    "axes",
-                    desc_like(xy, coordinates="axes"),
-                    desc_like(xy, coordinates="display"),
-                    transform=self.axes.transAxes,
-                )
-            )
+    def draw(self, renderer, graph=None):
+        if not self.get_visible():
+            return
 
-        self._artist.draw(renderer, edges)
+        if graph is None:
+            graph = Graph([])
+        self._artist.draw(renderer, graph + self._graph)
 
 
 class CompatibilityAxes:
@@ -111,11 +152,44 @@ class CompatibilityAxes:
     """
 
     def __init__(self, axes):
-        self.axes = axes
+        self._axes = axes
         self.figure = None
         self._clippath = None
+        self._visible = True
         self.zorder = 2
-        self._children = []
+        self._children: list[tuple[float, Artist]] = []
+
+    @property
+    def axes(self):
+        return self._axes
+
+    @axes.setter
+    def axes(self, ax):
+        self._axes = ax
+
+        if self._axes is None:
+            self._graph = Graph([])
+            return
+
+        desc: Desc = Desc(("N",), coordinates="data")
+        xy: dict[str, Desc] = {"x": desc, "y": desc}
+        self._graph = Graph(
+            [
+                TransformEdge(
+                    "data",
+                    xy,
+                    desc_like(xy, coordinates="axes"),
+                    transform=self._axes.transData - self._axes.transAxes,
+                ),
+                TransformEdge(
+                    "axes",
+                    desc_like(xy, coordinates="axes"),
+                    desc_like(xy, coordinates="display"),
+                    transform=self._axes.transAxes,
+                ),
+            ],
+            aliases=(("parent", "axes"),),
+        )
 
     def set_figure(self, fig):
         self.figure = fig
@@ -135,39 +209,28 @@ def set_clip_path(self, path):
     def get_animated(self):
         return False
 
-    def draw(self, renderer, edges=None):
-        if edges is None:
-            edges = []
+    def draw(self, renderer, graph=None):
+        if not self.visible:
+            return
+        if graph is None:
+            graph = Graph([])
 
-        if self.axes is not None:
-            desc: Desc = Desc(("N",), coordinates="data")
-            xy: dict[str, Desc] = {"x": desc, "y": desc}
-            edges.append(
-                TransformEdge(
-                    "data",
-                    xy,
-                    desc_like(xy, coordinates="axes"),
-                    transform=self.axes.transData - self.axes.transAxes,
-                )
-            )
-            edges.append(
-                TransformEdge(
-                    "axes",
-                    desc_like(xy, coordinates="axes"),
-                    desc_like(xy, coordinates="display"),
-                    transform=self.axes.transAxes,
-                )
-            )
+        graph = graph + self._graph
 
-        # TODO independent zorder
-        for c in self._children:
-            c.draw(renderer, edges)
+        for _, c in self._children:
+            c.draw(renderer, graph)
 
-    def add_artist(self, artist):
-        self._children.append(artist)
+    def add_artist(self, artist, zorder=1):
+        insort(self._children, (zorder, artist), key=lambda x: x[0])
 
     def set_xlim(self, min_=None, max_=None):
         self.axes.set_xlim(min_, max_)
 
     def set_ylim(self, min_=None, max_=None):
         self.axes.set_ylim(min_, max_)
+
+    def get_visible(self):
+        return self._visible
+
+    def set_visible(self, visible):
+        self._visible = visible

data_prototype/containers.py

@@ -82,11 +82,16 @@ class NoNewKeys(ValueError): ...
 
 
 class ArrayContainer:
-    def __init__(self, **data):
+    def __init__(self, coordinates: dict[str, str] | None = None, /, **data):
+        coordinates = coordinates or {}
         self._data = data
         self._cache_key = str(uuid.uuid4())
         self._desc = {
-            k: (Desc(v.shape) if isinstance(v, np.ndarray) else Desc(()))
+            k: (
+                Desc(v.shape, coordinates.get(k, "auto"))
+                if isinstance(v, np.ndarray)
+                else Desc(())
+            )
             for k, v in data.items()
         }
 

data_prototype/conversion_edge.py

@@ -225,8 +225,11 @@ def inverse(self) -> "TransformEdge":
 
 
 class Graph:
-    def __init__(self, edges: Sequence[Edge]):
-        self._edges = edges
+    def __init__(
+        self, edges: Sequence[Edge], aliases: tuple[tuple[str, str], ...] = ()
+    ):
+        self._edges = tuple(edges)
+        self._aliases = aliases
 
         self._subgraphs: list[tuple[set[str], list[Edge]]] = []
         for edge in self._edges:
@@ -245,29 +248,53 @@ def __init__(self, edges: Sequence[Edge]):
                 s |= keys
                 self._subgraphs[overlapping[0]][1].append(edge)
             else:
-                edges_combined = []
+                edges_combined = [edge]
                 for n in overlapping:
                     keys |= self._subgraphs[n][0]
                     edges_combined.extend(self._subgraphs[n][1])
                 for n in overlapping[::-1]:
                     self._subgraphs.pop(n)
                 self._subgraphs.append((keys, edges_combined))
 
+    def _resolve_alias(self, coord: str) -> str:
+        while True:
+            for coa, cob in self._aliases:
+                if coord == coa:
+                    coord = cob
+                    break
+            else:
+                break
+        return coord
+
     def evaluator(self, input: dict[str, Desc], output: dict[str, Desc]) -> Edge:
         out_edges = []
+
         for sub_keys, sub_edges in self._subgraphs:
             if not (sub_keys & set(output) or sub_keys & set(input)):
                 continue
+
             output_subset = {k: v for k, v in output.items() if k in sub_keys}
             sub_edges = sorted(sub_edges, key=lambda x: x.weight)
 
-            @dataclass(order=True)
+            @dataclass
             class Node:
                 weight: float
                 desc: dict[str, Desc]
                 prev_node: Node | None = None
                 edge: Edge | None = None
 
+                def __le__(self, other):
+                    return self.weight <= other.weight
+
+                def __lt__(self, other):
+                    return self.weight < other.weight
+
+                def __ge__(self, other):
+                    return self.weight >= other.weight
+
+                def __gt__(self, other):
+                    return self.weight > other.weight
+
             q: PriorityQueue[Node] = PriorityQueue()
             q.put(Node(0, input))
 
@@ -276,12 +303,12 @@ class Node:
                 n = q.get()
                 if n.weight > best.weight:
                     continue
-                if Desc.compatible(n.desc, output_subset):
+                if Desc.compatible(n.desc, output_subset, aliases=self._aliases):
                     if n.weight < best.weight:
                         best = n
                     continue
                 for e in sub_edges:
-                    if Desc.compatible(n.desc, e.input):
+                    if Desc.compatible(n.desc, e.input, aliases=self._aliases):
                         d = n.desc | e.output
                         w = n.weight + e.weight
 
@@ -328,6 +355,7 @@ class Node:
     def visualize(self, input: dict[str, Desc] | None = None):
         import networkx as nx
         import matplotlib.pyplot as plt
+
         from pprint import pformat
 
         def node_format(x):
@@ -376,3 +404,9 @@ def node_format(x):
         nx.draw(G, pos=pos, with_labels=True)
         nx.draw_networkx_edge_labels(G, pos=pos)
         # plt.show()
+
+    def __add__(self, other: Graph) -> Graph:
+        aself = {k: v for k, v in self._aliases}
+        aother = {k: v for k, v in other._aliases}
+        aliases = tuple((aself | aother).items())
+        return Graph(self._edges + other._edges, aliases)

data_prototype/description.py

@@ -103,17 +103,32 @@ def validate_shapes(
         return None
 
     @staticmethod
-    def compatible(a: dict[str, "Desc"], b: dict[str, "Desc"]) -> bool:
+    def compatible(
+        a: dict[str, "Desc"],
+        b: dict[str, "Desc"],
+        aliases: tuple[tuple[str, str], ...] = (),
+    ) -> bool:
         """Determine if ``a`` is a valid input for ``b``.
 
         Note: ``a`` _may_ have additional keys.
         """
+
+        def resolve_aliases(coord):
+            while True:
+                for coa, cob in aliases:
+                    if coord == coa:
+                        coord = cob
+                        break
+                else:
+                    break
+            return coord
+
         try:
             Desc.validate_shapes(b, a)
         except (KeyError, ValueError):
             return False
         for k, v in b.items():
-            if a[k].coordinates != v.coordinates:
+            if resolve_aliases(a[k].coordinates) != resolve_aliases(v.coordinates):
                 return False
         return True