Remove unused name field from Converters

Author: ksunden

data_prototype/conversion_node.py

@@ -17,7 +17,6 @@ def evaluate_pipeline(nodes: Sequence[ConversionNode], input: dict[str, Any]):
 
 @dataclass
 class ConversionNode:
-    name: str
     required_keys: tuple[str, ...]
     output_keys: tuple[str, ...]
     trim_keys: bool
@@ -43,12 +42,12 @@ class UnionConversionNode(ConversionNode):
     nodes: tuple[ConversionNode, ...]
 
     @classmethod
-    def from_nodes(cls, name: str, *nodes: ConversionNode, trim_keys=False):
+    def from_nodes(cls, *nodes: ConversionNode, trim_keys=False):
         required = tuple(set(k for n in nodes for k in n.required_keys))
         output = Counter(k for n in nodes for k in n.output_keys)
         if duplicate := {k for k, v in output.items() if v > 1}:
             raise ValueError(f"Duplicate keys from multiple input nodes: {duplicate}")
-        return cls(name, required, tuple(output), trim_keys, nodes)
+        return cls(required, tuple(output), trim_keys, nodes)
 
     def evaluate(self, input: dict[str, Any]) -> dict[str, Any]:
         return super().evaluate({k: v for n in self.nodes for k, v in n.evaluate(input).items()})
@@ -59,12 +58,12 @@ class RenameConversionNode(ConversionNode):
     mapping: dict[str, str]
 
     @classmethod
-    def from_mapping(cls, name: str, mapping: dict[str, str], trim_keys=False):
+    def from_mapping(cls, mapping: dict[str, str], trim_keys=False):
         required = tuple(mapping)
         output = Counter(mapping.values())
         if duplicate := {k for k, v in output.items() if v > 1}:
             raise ValueError(f"Duplicate output keys in mapping: {duplicate}")
-        return cls(name, required, tuple(output), trim_keys, mapping)
+        return cls(required, tuple(output), trim_keys, mapping)
 
     def evaluate(self, input: dict[str, Any]) -> dict[str, Any]:
         return super().evaluate({**input, **{out: input[inp] for (inp, out) in self.mapping.items()}})
@@ -79,14 +78,14 @@ def _sigs(self):
         return {k: (f, inspect.signature(f)) for k, f in self.funcs.items()}
 
     @classmethod
-    def from_funcs(cls, name: str, funcs: dict[str, Callable], trim_keys=False):
+    def from_funcs(cls, funcs: dict[str, Callable], trim_keys=False):
         sigs = {k: inspect.signature(f) for k, f in funcs.items()}
         output = tuple(sigs)
         input = []
         for v in sigs.values():
             input.extend(v.parameters.keys())
         input = tuple(set(input))
-        return cls(name, input, output, trim_keys, funcs)
+        return cls(input, output, trim_keys, funcs)
 
     def evaluate(self, input: dict[str, Any]) -> dict[str, Any]:
         return super().evaluate(
@@ -102,8 +101,8 @@ class LimitKeysConversionNode(ConversionNode):
     keys: set[str]
 
     @classmethod
-    def from_keys(cls, name: str, keys: Sequence[str]):
-        return cls(name, (), tuple(keys), trim_keys=True, keys=set(keys))
+    def from_keys(cls, keys: Sequence[str]):
+        return cls((), tuple(keys), trim_keys=True, keys=set(keys))
 
     def evaluate(self, input: dict[str, Any]) -> dict[str, Any]:
         return {k: v for k, v in input.items() if k in self.keys}

data_prototype/wrappers.py

@@ -163,7 +163,7 @@ def __init__(self, data, converters: ConversionNode | list[ConversionNode] | Non
         setters = list(self.expected_keys | self.required_keys)
         if hasattr(self, "_wrapped_class"):
             setters += [f[4:] for f in dir(self._wrapped_class) if f.startswith("set_")]
-        self._converters.append(LimitKeysConversionNode.from_keys("setters", setters))
+        self._converters.append(LimitKeysConversionNode.from_keys(setters))
         self.stale = True
 
 
@@ -196,9 +196,9 @@ class LineWrapper(ProxyWrapper):
     def __init__(self, data: DataContainer, converters=None, /, **kwargs):
         super().__init__(data, converters)
         self._wrapped_instance = self._wrapped_class(np.array([]), np.array([]), **kwargs)
-        self._converters.insert(-1, RenameConversionNode.from_mapping("xydata", {"x": "xdata", "y": "ydata"}))
+        self._converters.insert(-1, RenameConversionNode.from_mapping({"x": "xdata", "y": "ydata"}))
         setters = [f[4:] for f in dir(self._wrapped_class) if f.startswith("set_")]
-        self._converters[-1] = LimitKeysConversionNode.from_keys("setters", setters)
+        self._converters[-1] = LimitKeysConversionNode.from_keys(setters)
 
     @_stale_wrapper
     def draw(self, renderer):
@@ -261,9 +261,7 @@ def __init__(self, data: DataContainer, converters=None, /, cmap=None, norm=None
                 cmap = mpl.colormaps["viridis"]
             if norm is None:
                 raise ValueError("not sure how to do autoscaling yet")
-            converters.append(
-                FunctionConversionNode.from_funcs("map colors", {"image": lambda image: cmap(norm(image))})
-            )
+            converters.append(FunctionConversionNode.from_funcs({"image": lambda image: cmap(norm(image))}))
         super().__init__(data, converters)
         kwargs.setdefault("origin", "lower")
         self._wrapped_instance = self._wrapped_class(None, **kwargs)

examples/2Dfunc.py

@@ -13,7 +13,6 @@
 from data_prototype.wrappers import ImageWrapper
 from data_prototype.containers import FuncContainer
 
-import matplotlib as mpl
 from matplotlib.colors import Normalize
 
 
@@ -25,9 +24,8 @@
         "image": (("N", "M"), lambda x, y: np.sin(x).reshape(1, -1) * np.cos(y).reshape(-1, 1)),
     },
 )
-cmap = mpl.colormaps["viridis"]
-norm = Normalize(-1, 1)
-im = ImageWrapper(fc)
+norm = Normalize(vmin=-1, vmax=1)
+im = ImageWrapper(fc, norm=norm)
 
 fig, ax = plt.subplots()
 ax.add_artist(im)

examples/animation.py

@@ -65,7 +65,7 @@ def update(frame, art):
 fc = FormatedText(
     sot_c,
     FunctionConversionNode.from_funcs(
-        "fmt", {"text": lambda phase: f"ϕ={phase:.2f}", "x": lambda: 2 * np.pi, "y": lambda: 1}
+        {"text": lambda phase: f"ϕ={phase:.2f}", "x": lambda: 2 * np.pi, "y": lambda: 1}
     ),
     ha="right",
 )

examples/mapped.py

@@ -22,7 +22,6 @@
 norm = Normalize(1, 8)
 
 line_converter = FunctionConversionNode.from_funcs(
-    "line converter",
     {
         # arbitrary functions
         "lw": lambda lw: min(1 + lw, 5),
@@ -34,7 +33,6 @@
 )
 
 text_converter = FunctionConversionNode.from_funcs(
-    "text converter",
     {
         "text": lambda j, cat: f"index={j[()]} class={cat[()]!r}",
         "y": lambda j: j,

examples/mulivariate_cmap.py

@@ -41,7 +41,7 @@ def image_nu(image):
     },
 )
 
-im = ImageWrapper(fc, FunctionConversionNode.from_funcs("bivariate", {"image": image_nu}))
+im = ImageWrapper(fc, FunctionConversionNode.from_funcs({"image": image_nu}))
 
 fig, ax = plt.subplots()
 ax.add_artist(im)

examples/widgets.py

@@ -118,7 +118,7 @@ def _query_hash(self, coord_transform, size):
 lw = LineWrapper(
     fc,
     # color map phase (scaled to 2pi and wrapped to [0, 1])
-    FunctionConversionNode.from_funcs("cmap", {"color": lambda color: cmap((color / (2 * np.pi)) % 1)}),
+    FunctionConversionNode.from_funcs({"color": lambda color: cmap((color / (2 * np.pi)) % 1)}),
     lw=5,
 )
 ax.add_artist(lw)