Remove _utils.ipython.get_display_function

The previous change made this function an unneccessary.

Author: has2k1

plotnine/_utils/ipython.py

@@ -3,17 +3,9 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Callable, Literal, NotRequired, TypeAlias, TypedDict
-
     from IPython.core.interactiveshell import InteractiveShell
 
-    FigureFormat: TypeAlias = Literal[
-        "png", "retina", "jpeg", "jpg", "svg", "pdf"
-    ]
-
-    class DisplayMetadata(TypedDict):
-        width: NotRequired[int]
-        height: NotRequired[int]
+    from ..typing import DisplayMetadata, FigureFormat, MimeBundle
 
 
 def get_ipython() -> "None | InteractiveShell":
@@ -28,36 +20,21 @@ def get_ipython() -> "None | InteractiveShell":
     return _get_ipython()
 
 
-def is_inline_backend():
+def is_inline_backend() -> bool:
     """
     Return True if the inline_backend is on
 
     This can only be True if also running in an jupyter/ipython session.
     """
     import matplotlib as mpl
 
-    return "matplotlib_inline.backend_inline" in mpl.get_backend()
-
-
-def get_display_function() -> Callable[
-    [dict[str, bytes], dict[str, DisplayMetadata]], None
-]:
-    """
-    Return a function that will display the plot image
-    """
-    from IPython.display import display
-
-    def display_func(
-        data: dict[str, bytes], metadata: dict[str, DisplayMetadata]
-    ) -> None:
-        display(data, metadata=metadata, raw=True)
-
-    return display_func
+    backend = mpl.get_backend()
+    return backend in ("inline", "module://matplotlib_inline.backend_inline")
 
 
 def get_mimebundle(
     b: bytes, format: FigureFormat, figure_size_px: tuple[int, int]
-):
+) -> MimeBundle:
     """
     Return a the display MIME bundle from image data
 

plotnine/composition/_compose.py

@@ -6,7 +6,12 @@
 from io import BytesIO
 from typing import TYPE_CHECKING, overload
 
-from .._utils.ipython import get_display_function, get_ipython, get_mimebundle
+from .._utils.ipython import (
+    get_ipython,
+    get_mimebundle,
+    is_inline_backend,
+)
+from .._utils.quarto import is_quarto_environment
 from ..options import get_option
 from ._plotspec import plotspec
 
@@ -18,7 +23,7 @@
 
     from plotnine._mpl.gridspec import p9GridSpec
     from plotnine.ggplot import PlotAddable, ggplot
-    from plotnine.typing import FigureFormat
+    from plotnine.typing import FigureFormat, MimeBundle
 
 
 @dataclass
@@ -215,7 +220,7 @@ def __getitem__(
     def __setitem__(self, key, value):
         self.items[key] = value
 
-    def _repr_mimebundle_(self, **kwargs):
+    def _repr_mimebundle_(self, include=None, exclude=None) -> MimeBundle:
         """
         Return dynamic MIME bundle for composition display
         """
@@ -359,18 +364,24 @@ def _make_plotspecs(
         self.figure = plt.figure()
         self.plotspecs = list(_make_plotspecs(self, None))
 
-    def _display(self):
+    def show(self):
         """
         Display plot in the cells output
 
         This function is called for its side-effects.
-
-        It draws the plot to an io buffer then uses ipython display
-        methods to show the result.
         """
-        data, metadata = self._repr_mimebundle_()
-        display_func = get_display_function()
-        display_func(data, metadata)
+        # Prevent against any modifications to the users
+        # ggplot object. Do the copy here as we may/may not
+        # assign a default theme
+        self = deepcopy(self)
+
+        if is_inline_backend() or is_quarto_environment():
+            from IPython.display import display
+
+            data, metadata = self._repr_mimebundle_()
+            display(data, metadata=metadata, raw=True)
+        else:
+            self.draw(show=True)
 
     def draw(self, *, show: bool = False) -> Figure:
         """

plotnine/ggplot.py

@@ -25,7 +25,6 @@
 )
 from ._utils.context import plot_context
 from ._utils.ipython import (
-    get_display_function,
     get_ipython,
     get_mimebundle,
     is_inline_backend,
@@ -56,7 +55,7 @@
     from plotnine.composition import Compose
     from plotnine.coords.coord import coord
     from plotnine.facets.facet import facet
-    from plotnine.typing import DataLike, FigureFormat
+    from plotnine.typing import DataLike, FigureFormat, MimeBundle
 
     class PlotAddable(Protocol):
         """
@@ -138,11 +137,15 @@ def __str__(self) -> str:
         w, h = self.theme._figure_size_px
         return f"<ggplot: ({w} x {h})>"
 
-    def _repr_mimebundle_(self, **kwargs):
+    def _repr_mimebundle_(self, include=None, exclude=None) -> MimeBundle:
         """
         Return dynamic MIME bundle for plot display
 
         This method is called when a ggplot object is the last in the cell.
+
+        Notes
+        -----
+        - https://ipython.readthedocs.io/en/stable/config/integrating.html
         """
         ip = get_ipython()
         format: FigureFormat = (
@@ -166,34 +169,21 @@ def show(self):
         """
         Show plot using the matplotlib backend set by the user
 
-        Users should prefer this method instead of printing or repring
-        the object.
+        This function is called for its side-effects.
         """
         # Prevent against any modifications to the users
         # ggplot object. Do the copy here as we may/may not
         # assign a default theme
         self = deepcopy(self)
 
         if is_inline_backend() or is_quarto_environment():
-            # Take charge of the display because we have to make
-            # adjustments for retina output.
-            self._display()
+            from IPython.display import display
+
+            data, metadata = self._repr_mimebundle_()
+            display(data, metadata=metadata, raw=True)
         else:
             self.draw(show=True)
 
-    def _display(self):
-        """
-        Display plot in the cells output
-
-        This function is called for its side-effects.
-
-        It plots the plot to an io buffer, then uses ipython display
-        methods to show the result
-        """
-        data, metadata = self._repr_mimebundle_()
-        display_func = get_display_function()
-        display_func(data, metadata)
-
     def __deepcopy__(self, memo: dict[Any, Any]) -> ggplot:
         """
         Deep copy without copying the dataframe and environment

plotnine/typing.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-import sys
-from datetime import datetime, timedelta
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Literal,
+    NotRequired,
     Protocol,
     Sequence,
+    TypedDict,
     TypeVar,
 )
 
@@ -142,3 +141,15 @@ class PTransform(Protocol):
     """
 
     def __call__(self, x: TFloatArrayLike) -> TFloatArrayLike: ...
+
+
+class DisplayMetadata(TypedDict):
+    """
+    Metadata for the IPython output
+    """
+
+    width: NotRequired[int]
+    height: NotRequired[int]
+
+
+MimeBundle: TypeAlias = tuple[dict[str, bytes], dict[str, DisplayMetadata]]