Remove from_geom, from_stat, and to_layer in favor of layer(geom=...) and layer(stat=...)

Extract _lookup_stat for pure spec→class/instance resolution and add
stat-first detection in layer.__init__ so that layer(stat="bin") derives
the correct geom. This makes from_geom, from_stat, and to_layer
redundant — all callers now use layer() directly.

Author: has2k1

plotnine/geoms/annotate.py

@@ -15,7 +15,6 @@
     from typing import Any
 
     from plotnine import ggplot
-    from plotnine.layer import layer
 
 
 class annotate:
@@ -135,16 +134,7 @@ def __radd__(self, other: ggplot) -> ggplot:
         """
         Add to ggplot
         """
-        other += self.to_layer()  # Add layer
-        return other
-
-    def to_layer(self) -> layer:
-        """
-        Make a layer that represents this annotation
+        from ..layer import layer
 
-        Returns
-        -------
-        out : layer
-            Layer
-        """
-        return self._annotation_geom.to_layer()
+        other += layer(geom=self._annotation_geom)
+        return other

plotnine/geoms/geom.py

@@ -430,20 +430,9 @@ def __radd__(self, other: ggplot) -> ggplot:
         :
             ggplot object with added layer.
         """
-        other += self.to_layer()  # Add layer
+        other += layer(geom=self)
         return other
 
-    def to_layer(self) -> layer:
-        """
-        Make a layer that represents this geom
-
-        Returns
-        -------
-        :
-            Layer
-        """
-        return layer.from_geom(self)
-
     def handle_na(self, data: pd.DataFrame) -> pd.DataFrame:
         """
         Remove rows with NaN values

plotnine/layer.py

@@ -78,7 +78,7 @@ class layer:
 
     def __init__(
         self,
-        geom: geom | type[geom] | str = "blank",
+        geom: geom | type[geom] | str | None = None,
         stat: stat | type[stat] | str | None = None,
         *,
         mapping: aes | None = None,
@@ -89,15 +89,31 @@ def __init__(
         raster: bool = False,
         **kwargs: Any,
     ):
+        # Stat-first: derive geom from stat's default
+        if stat is not None:
+            stat_ref = _lookup_stat(stat)
+            if isinstance(stat_ref, type):
+                geom = stat_ref.DEFAULT_PARAMS.get("geom", "blank")
+            else:
+                geom = stat_ref.params.get("geom", "blank")
+                # Forward stat instance's kwargs to the geom
+                if mapping is None and data is None and not kwargs:
+                    mapping = stat_ref._raw_kwargs.get("mapping")
+                    data = stat_ref._raw_kwargs.get("data")
+                    kwargs = {
+                        k: v
+                        for k, v in stat_ref._raw_kwargs.items()
+                        if k not in ("mapping", "data")
+                    }
+
+        if geom is None:
+            geom = "blank"
+
         _geom = _resolve_geom(geom, mapping, data, kwargs)
         _stat = _resolve_stat(stat, _geom)
         _pos = _resolve_position(position, _geom)
         self._verify_arguments(_geom, _stat)
 
-        # Set back-references for pipeline compat
-        _geom._stat = _stat  # pyright: ignore[reportAttributeAccessIssue]
-        _geom._position = _pos  # pyright: ignore[reportAttributeAccessIssue]
-
         # Layer params: prefer explicit kwargs, fall back to
         # geom._raw_kwargs, then geom.DEFAULT_PARAMS
         raw = _geom._raw_kwargs
@@ -121,56 +137,6 @@ def __init__(
         self.position = _pos
         self.zorder = 0
 
-    @staticmethod
-    def from_geom(geom: geom) -> layer:
-        """
-        Create a layer given a [](`~plotnine.geoms.geom`)
-
-        Parameters
-        ----------
-        geom :
-            `geom` from which a layer will be created
-
-        Returns
-        -------
-        :
-            Layer that represents the specific `geom`.
-        """
-        return layer(geom=geom)
-
-    @staticmethod
-    def from_stat(stat: stat) -> layer:
-        """
-        Create a layer given a [](`~plotnine.stats.stat`)
-
-        Parameters
-        ----------
-        stat :
-            `stat` from which a layer will be created
-
-        Returns
-        -------
-        :
-            Layer that represents the specific `stat`.
-        """
-        from .geoms.geom import geom as geom_cls
-
-        name = stat.params.get("geom", "blank")
-
-        if isinstance(name, geom_cls):
-            return layer(geom=name)
-
-        if isinstance(name, type) and issubclass(name, geom_cls):
-            klass = name
-        elif isinstance(name, str):
-            if not name.startswith("geom_"):
-                name = f"geom_{name}"
-            klass = Registry[name]
-        else:
-            raise PlotnineError(f"Unknown geom of type {type(name)}")
-
-        return layer(geom=klass(stat=stat, **stat._raw_kwargs))
-
     @staticmethod
     def _verify_arguments(geom: geom, stat: stat) -> None:
         """
@@ -683,6 +649,43 @@ def _resolve_geom(
     return klass(mapping, data, **kwargs)
 
 
+def _lookup_stat(
+    stat_spec: stat | type[stat] | str,
+) -> stat | type[stat]:
+    """
+    Look up a stat specification without instantiation
+
+    Parameters
+    ----------
+    stat_spec :
+        A stat instance, class, or string name.
+
+    Returns
+    -------
+    :
+        The stat instance or class.
+    """
+    from .stats.stat import stat as stat_cls
+
+    # Duck-type guard for module reloads
+    if not isinstance(stat_spec, type) and hasattr(stat_spec, "compute_layer"):
+        return stat_spec  # type: ignore[return-value]
+
+    if isinstance(stat_spec, stat_cls):
+        return stat_spec
+
+    if isinstance(stat_spec, type) and issubclass(stat_spec, stat_cls):
+        return stat_spec
+
+    if isinstance(stat_spec, str):
+        name = stat_spec
+        if not name.startswith("stat_"):
+            name = f"stat_{name}"
+        return Registry[name]
+
+    raise PlotnineError(f"Unknown stat of type {type(stat_spec)}")
+
+
 def _resolve_stat(
     stat_spec: stat | type[stat] | str | None,
     geom_obj: geom,
@@ -703,24 +706,13 @@ def _resolve_stat(
     if stat_spec is None:
         stat_spec = geom_obj.params["stat"]
 
-    # Duck-type guard for module reloads
-    if not isinstance(stat_spec, type) and hasattr(stat_spec, "compute_layer"):
-        return stat_spec  # type: ignore[return-value]
-
-    if isinstance(stat_spec, stat_cls):
-        return stat_spec
+    result = _lookup_stat(stat_spec)  # type: ignore[arg-type]
 
-    if isinstance(stat_spec, type) and issubclass(stat_spec, stat_cls):
-        klass = stat_spec
-    elif isinstance(stat_spec, str):
-        name = stat_spec
-        if not name.startswith("stat_"):
-            name = f"stat_{name}"
-        klass = Registry[name]
-    else:
-        raise PlotnineError(f"Unknown stat of type {type(stat_spec)}")
+    if isinstance(result, stat_cls):
+        return result
 
-    # Filter geom's raw kwargs to stat-relevant keys
+    # It's a class — instantiate with filtered geom kwargs
+    klass = result
     kwargs = geom_obj._raw_kwargs
     valid_kwargs = (
         klass.aesthetics() | klass.DEFAULT_PARAMS.keys()

plotnine/stats/stat.py

@@ -346,16 +346,5 @@ def __radd__(self, other: ggplot) -> ggplot:
         out :
             ggplot object with added layer
         """
-        other += self.to_layer()  # Add layer
+        other += layer(stat=self)
         return other
-
-    def to_layer(self) -> layer:
-        """
-        Make a layer that represents this stat
-
-        Returns
-        -------
-        out :
-            Layer
-        """
-        return layer.from_stat(self)

tests/test_geom.py

@@ -47,18 +47,18 @@ class geom_abc(geom):
         DEFAULT_PARAMS = {"stat": "identity", "position": "identity"}
 
     with pytest.raises(PlotnineError):
-        geom_abc(do_the_impossible=True).to_layer()
+        layer(geom=geom_abc(do_the_impossible=True))
 
 
 def test_geom_from_stat():
     stat = stat_identity(geom="point")
-    assert isinstance(layer.from_stat(stat).geom, geom_point)
+    assert isinstance(layer(stat=stat).geom, geom_point)
 
     stat = stat_identity(geom="geom_point")
-    assert isinstance(layer.from_stat(stat).geom, geom_point)
+    assert isinstance(layer(stat=stat).geom, geom_point)
 
     stat = stat_identity(geom=geom_point())
-    assert isinstance(layer.from_stat(stat).geom, geom_point)
+    assert isinstance(layer(stat=stat).geom, geom_point)
 
     stat = stat_identity(geom=geom_point)
-    assert isinstance(layer.from_stat(stat).geom, geom_point)
+    assert isinstance(layer(stat=stat).geom, geom_point)

tests/test_layers.py

@@ -42,15 +42,15 @@ def test_addition(self):
         assert _get_colors(p2) == colors
 
         # Real layers
-        lyrs = Layers(layer.from_geom(obj) for obj in self.lyrs)
+        lyrs = Layers(layer(geom=obj) for obj in self.lyrs)
         p3 = p + lyrs
         assert _get_colors(p3) == colors
 
         p += self.lyrs
         assert _get_colors(p) == colors
 
         with pytest.raises(PlotnineError):
-            geom_point() + layer.from_geom(geom_point())
+            geom_point() + layer(geom=geom_point())
 
         with pytest.raises(PlotnineError):
             geom_point() + self.lyrs
@@ -77,7 +77,7 @@ def __init__(self, obj):
             self.obj = obj
 
         def __radd__(self, other):
-            other.layers.insert(0, self.obj.to_layer())
+            other.layers.insert(0, layer(geom=self.obj))
             return other
 
     p = (

tests/test_position.py

@@ -26,6 +26,7 @@
     stage,
 )
 from plotnine.exceptions import PlotnineError
+from plotnine.layer import layer
 
 n = 6
 m = 10
@@ -240,16 +241,16 @@ def test_jitterdodge():
 
 
 def test_position_from_geom():
-    lyr = geom_point(position="jitter").to_layer()
+    lyr = layer(geom=geom_point(position="jitter"))
     assert isinstance(lyr.position, position_jitter)
 
-    lyr = geom_point(position="position_jitter").to_layer()
+    lyr = layer(geom=geom_point(position="position_jitter"))
     assert isinstance(lyr.position, position_jitter)
 
-    lyr = geom_point(position=position_jitter()).to_layer()
+    lyr = layer(geom=geom_point(position=position_jitter()))
     assert isinstance(lyr.position, position_jitter)
 
-    lyr = geom_point(position=position_jitter).to_layer()
+    lyr = layer(geom=geom_point(position=position_jitter))
     assert isinstance(lyr.position, position_jitter)
 
 

tests/test_stat.py

@@ -5,6 +5,7 @@
 from plotnine.data import mtcars
 from plotnine.exceptions import PlotnineError, PlotnineWarning
 from plotnine.geoms.geom import geom
+from plotnine.layer import layer
 from plotnine.stats.stat import stat
 
 
@@ -55,12 +56,12 @@ def draw(pinfo, panel_params, coord, ax, **kwargs):
     # not a geom manual setting
     g = geom_abc(weight=4)
     assert "weight" in g.aes_params
-    lyr = g.to_layer()
+    lyr = layer(geom=g)
     assert "weight" in lyr.stat.params
 
     g = geom_abc(aes(weight="mpg"))
     assert "weight" in g.mapping
-    lyr = g.to_layer()
+    lyr = layer(geom=g)
     assert "weight" in lyr.stat.params