Use IPython display

1. Makes it possible to avoid string output that follows the output image.
2. Gained the ability to control the interactive figure format from
   within plotnine.

closes #694

doc/_quartodoc.yml

@@ -548,6 +548,7 @@ quartodoc:
         - current_theme
         - dpi
         - figure_size
+        - figure_format
         - get_option
         - set_option
 

doc/changelog.qmd

@@ -8,14 +8,25 @@ title: Changelog
 ### API Changes
 
 - Requires python >= 3.9
+
 - The name of the calculated aesthetic of
   [](:class:`~plotnine.stats.stat_function`) changed from `y` to `fx`.
+
 - [](:class:`~plotnine.stats.stat_ecdf`) has gained the `pad` parameter. The
   default is set to `True`, which pads the domain with `-inf` and `inf` so
   that the ECDF does not have discontinuities at the extremes. To get the
   behaviour, set `pad` to `False`. ({{< issue 725 >}})
+
 - Removed the environment parameter from `ggplot`.
 
+- When a ggplot object is the last in a jupyter cell, the output image will
+  not be followed by string meta information about the figure/image.
+
+  This will happen even if the backend is set to an interactive one.
+
+  If you set the backend to an interactive one, use
+  [](:class:`~plotnine.ggplot.show`) to draw the plot.
+
 ### New
 
 - Added symmetric logarithm transformation scales
@@ -51,6 +62,17 @@ title: Changelog
   accept lists/tuples to set the values on individual text objects.
   ({{< issue 724 >}})
 
+- Gained the option [](:attr:`~plotnine.options.figure_format`) to set the format
+  of the inline figures in an interactive session. e.g.
+
+  ```python
+  from plotnine.options import set_option
+
+  set_option("figure_format", "svg")
+  ```
+
+  will output all subsequent figures in svg format.
+
 ### Bug Fixes
 
 - Fixed handling of minor breaks in

plotnine/_utils/__init__.py

@@ -25,7 +25,6 @@
     from typing import Any, Callable
 
     import numpy.typing as npt
-    from IPython.core.interactiveshell import InteractiveShell
     from matplotlib.typing import ColorType
     from typing_extensions import TypeGuard
 
@@ -1186,17 +1185,6 @@ def __exit__(self, type, value, traceback):
         return self._cm.__exit__(type, value, traceback)
 
 
-def get_ipython() -> "InteractiveShell | None":
-    """
-    Return running IPython instance or None
-    """
-    try:
-        from IPython.core.getipython import get_ipython
-    except ImportError:
-        return None
-    return get_ipython()
-
-
 def simple_table(
     rows: list[tuple[str, str]], headers: tuple[str, str], **kwargs
 ):

plotnine/_utils/context.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pandas as pd
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from plotnine import ggplot
+
+
+class plot_context:
+    """
+    Context to setup the environment within with the plot is built
+
+    Parameters
+    ----------
+    plot :
+        ggplot object to be built within the context.
+        exits.
+    show :
+        Whether to show the plot.
+    """
+
+    def __init__(self, plot: ggplot, show: bool = False):
+        self.plot = plot
+        self.show = show
+
+    def __enter__(self) -> Self:
+        """
+        Enclose in matplolib & pandas environments
+        """
+        import matplotlib as mpl
+
+        self.plot.theme._targets = {}
+        self.rc_context = mpl.rc_context(self.plot.theme.rcParams)
+
+        # Pandas deprecated is_copy, and when we create new dataframes
+        # from slices we do not want complaints. We always uses the
+        # new frames knowing that they are separate from the original.
+        self.pd_option_context = pd.option_context(
+            "mode.chained_assignment", None
+        )
+        self.rc_context.__enter__()
+        self.pd_option_context.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        """
+        Exit matplotlib & pandas environments
+        """
+        import matplotlib.pyplot as plt
+
+        if exc_type is None:
+            if self.show:
+                plt.show()
+            else:
+                plt.close(self.plot.figure)
+        else:
+            # There is an exception, close any figure
+            if hasattr(self.plot, "figure"):
+                plt.close(self.plot.figure)
+
+        self.rc_context.__exit__(exc_type, exc_value, exc_traceback)
+        self.pd_option_context.__exit__(exc_type, exc_value, exc_traceback)
+        delattr(self.plot.theme, "_targets")

plotnine/_utils/ipython.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Callable, Literal, TypeAlias
+
+    from IPython.core.interactiveshell import InteractiveShell
+
+    FigureFormat: TypeAlias = Literal[
+        "png", "retina", "jpeg", "jpg", "svg", "pdf"
+    ]
+
+
+def get_ipython() -> "InteractiveShell":
+    """
+    Return running IPython instance or None
+    """
+    try:
+        from IPython.core.getipython import get_ipython as _get_ipython
+    except ImportError as err:
+        raise type(err)("IPython is has not been installed.") from err
+
+    ip = _get_ipython()
+    if ip is None:
+        raise RuntimeError("Not running in a juptyer session.")
+
+    return ip
+
+
+def is_inline_backend():
+    """
+    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(format: FigureFormat) -> Callable[[bytes], None]:
+    """
+    Return a function that will display the plot image
+    """
+    from IPython.display import (
+        SVG,
+        Image,
+        display_jpeg,
+        display_pdf,
+        display_png,
+        display_svg,
+    )
+
+    def png(b: bytes):
+        display_png(Image(b, format="png"))
+
+    def retina(b: bytes):
+        display_png(Image(b, format="png", retina=True))
+
+    def jpeg(b: bytes):
+        display_jpeg(Image(b, format="jpeg"))
+
+    def svg(b: bytes):
+        display_svg(SVG(b))
+
+    def pdf(b: bytes):
+        display_pdf(b, raw=True)
+
+    lookup = {
+        "png": png,
+        "retina": retina,
+        "jpeg": jpeg,
+        "jpg": jpeg,
+        "svg": svg,
+        "pdf": pdf,
+    }
+    return lookup[format]