Inline geom.from_stat, stat.from_geom, and position.from_geom into layer resolvers

These factory methods are now inlined into the layer.py resolver
functions (_resolve_stat, _resolve_position, layer.from_stat),
centralising all component resolution in one place. Tests updated
to exercise resolution through the layer API.

Author: has2k1

plotnine/geoms/geom.py

@@ -12,7 +12,7 @@
     data_mapping_as_kwargs,
     remove_missing,
 )
-from .._utils.registry import Register, Registry
+from .._utils.registry import Register
 from ..exceptions import PlotnineError
 from ..layer import layer
 from ..mapping.aes import rename_aesthetics
@@ -30,7 +30,6 @@
     from plotnine.facets.layout import Layout
     from plotnine.iapi import panel_view
     from plotnine.mapping import Environment
-    from plotnine.stats.stat import stat
     from plotnine.typing import DataLike
 
 
@@ -92,44 +91,6 @@ def __init__(
         self.mapping = kwargs["mapping"]
         self.data = kwargs["data"]
 
-    @staticmethod
-    def from_stat(stat: stat) -> geom:
-        """
-        Return an instantiated geom object
-
-        geoms should not override this method.
-
-        Parameters
-        ----------
-        stat :
-            `stat`
-
-        Returns
-        -------
-        :
-            A geom object
-
-        Raises
-        ------
-        PlotnineError
-            If unable to create a `geom`.
-        """
-        name = stat.params.get("geom", "blank")
-
-        if isinstance(name, geom):
-            return name
-
-        if isinstance(name, type) and issubclass(name, geom):
-            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 klass(stat=stat, **stat._raw_kwargs)
-
     @classmethod
     def aesthetics(cls: type[geom]) -> set[str]:
         """

plotnine/layer.py

@@ -155,8 +155,21 @@ def from_stat(stat: stat) -> layer:
         """
         from .geoms.geom import geom as geom_cls
 
-        _geom = geom_cls.from_stat(stat)
-        return layer(geom=_geom)
+        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:
@@ -688,7 +701,7 @@ def _resolve_stat(
     from .stats.stat import stat as stat_cls
 
     if stat_spec is None:
-        return stat_cls.from_geom(geom_obj)
+        stat_spec = geom_obj.params["stat"]
 
     # Duck-type guard for module reloads
     if not isinstance(stat_spec, type) and hasattr(stat_spec, "compute_layer"):
@@ -734,7 +747,7 @@ def _resolve_position(
     from .positions.position import position as position_cls
 
     if position_spec is None:
-        return position_cls.from_geom(geom_obj)
+        position_spec = geom_obj.params["position"]
 
     if isinstance(position_spec, position_cls):
         return position_spec

plotnine/positions/position.py

@@ -8,7 +8,7 @@
 import numpy as np
 
 from .._utils import check_required_aesthetics, groupby_apply
-from .._utils.registry import Register, Registry
+from .._utils.registry import Register
 from ..exceptions import PlotnineError, PlotnineWarning
 from ..mapping.aes import X_AESTHETICS, Y_AESTHETICS
 
@@ -18,7 +18,6 @@
     import pandas as pd
 
     from plotnine.facets.layout import Layout
-    from plotnine.geoms.geom import geom
     from plotnine.iapi import pos_scales
     from plotnine.typing import TransformCol
 
@@ -132,41 +131,6 @@ def transform_position(
 
         return data
 
-    @staticmethod
-    def from_geom(geom: geom) -> position:
-        """
-        Create and return a position object for the geom
-
-        Parameters
-        ----------
-        geom : geom
-            An instantiated geom object.
-
-        Returns
-        -------
-        out : position
-            A position object
-
-        Raises
-        ------
-        PlotnineError
-            If unable to create a `position`.
-        """
-        name = geom.params["position"]
-        if issubclass(type(name), position):
-            return name
-
-        if isinstance(name, type) and issubclass(name, position):
-            klass = name
-        elif isinstance(name, str):
-            if not name.startswith("position_"):
-                name = f"position_{name}"
-            klass = Registry[name]
-        else:
-            raise PlotnineError(f"Unknown position of type {type(name)}")
-
-        return klass()
-
     @staticmethod
     def strategy(data: pd.DataFrame, params: dict[str, Any]) -> pd.DataFrame:
         """

plotnine/stats/stat.py

@@ -12,8 +12,7 @@
     remove_missing,
     uniquecols,
 )
-from .._utils.registry import Register, Registry
-from ..exceptions import PlotnineError
+from .._utils.registry import Register
 from ..layer import layer
 from ..mapping import aes
 
@@ -22,7 +21,6 @@
 
     from plotnine import ggplot
     from plotnine.facets.layout import Layout
-    from plotnine.geoms.geom import geom
     from plotnine.iapi import pos_scales
     from plotnine.mapping import Environment
     from plotnine.typing import DataLike
@@ -82,52 +80,6 @@ def __init__(
             ae: kwargs[ae] for ae in self.aesthetics() & set(kwargs)
         }
 
-    @staticmethod
-    def from_geom(geom: geom) -> stat:
-        """
-        Return an instantiated stat object
-
-        stats should not override this method.
-
-        Parameters
-        ----------
-        geom :
-            A geom object
-
-        Returns
-        -------
-        stat
-            A stat object
-
-        Raises
-        ------
-        [](`~plotnine.exceptions.PlotnineError`) if unable to create a `stat`.
-        """
-        name = geom.params["stat"]
-        kwargs = geom._raw_kwargs
-        # More stable when reloading modules than
-        # using issubclass
-        if not isinstance(name, type) and hasattr(name, "compute_layer"):
-            return name
-
-        if isinstance(name, stat):
-            return name
-        elif isinstance(name, type) and issubclass(name, stat):
-            klass = name
-        elif isinstance(name, str):
-            if not name.startswith("stat_"):
-                name = f"stat_{name}"
-            klass = Registry[name]
-        else:
-            raise PlotnineError(f"Unknown stat of type {type(name)}")
-
-        valid_kwargs = (
-            klass.aesthetics() | klass.DEFAULT_PARAMS.keys()
-        ) & kwargs.keys()
-
-        params = {k: kwargs[k] for k in valid_kwargs}
-        return klass(geom=geom, **params)
-
     def __deepcopy__(self, memo: dict[Any, Any]) -> stat:
         """
         Deep copy without copying the self.data dataframe

tests/test_geom.py

@@ -4,6 +4,7 @@
 from plotnine import aes, geom_point, ggplot, stat_identity
 from plotnine.exceptions import PlotnineError
 from plotnine.geoms.geom import geom
+from plotnine.layer import layer
 
 data = pd.DataFrame({"col1": [1, 2, 3, 4], "col2": 2, "col3": list("abcd")})
 
@@ -51,13 +52,13 @@ class geom_abc(geom):
 
 def test_geom_from_stat():
     stat = stat_identity(geom="point")
-    assert isinstance(geom.from_stat(stat), geom_point)
+    assert isinstance(layer.from_stat(stat).geom, geom_point)
 
     stat = stat_identity(geom="geom_point")
-    assert isinstance(geom.from_stat(stat), geom_point)
+    assert isinstance(layer.from_stat(stat).geom, geom_point)
 
     stat = stat_identity(geom=geom_point())
-    assert isinstance(geom.from_stat(stat), geom_point)
+    assert isinstance(layer.from_stat(stat).geom, geom_point)
 
     stat = stat_identity(geom=geom_point)
-    assert isinstance(geom.from_stat(stat), geom_point)
+    assert isinstance(layer.from_stat(stat).geom, geom_point)

tests/test_position.py

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