Source code for rpy2.robjects.lib.ggplot2

"""
Wrapper for the popular R library ggplot2.

With rpy2, the most convenient general way to
import packages is to use `importr()`, for example
with ggplot2::

    from rpy2.robjects.packages import importr
    ggplot2 = importr('ggplot2')

This module is an supplementary layer in which an attempt
at modelling the package as it was really developed
as Python package is made. Behind the scene, `importr()`
is used and can be accessed with:

    from robjects.robjects.lib import ggplot2
    ggplot2.ggplot2

GGplot2 is designed using a prototype-based approach to
Object-Oriented Programming, and this module is trying
to define class-hierachies so the nature of a given
instance can be identified more easily.

The main families of classes are:

- GGplot
- Aes and AesString
- Layer
- Stat

A downside of the approach is that the code in the
module is 'hand-made'. In hindsight, this can be tedious
to maintain and document but this is a good showcase of
"manual" mapping of R code into Python classes.

The codebase in R for ggplot2 has evolved since this
was initially written, and many functions have
signature-defined parameters (used to be ellipsis
about everywhere). Metaprogramming will hopefully
be added to shorten the Python code in the module,
and provide a more dynamic mapping.

"""


import rpy2.robjects as robjects
import rpy2.robjects.conversion as conversion
import rpy2.rinterface as rinterface
from rpy2.robjects.packages import importr, WeakPackage
import copy
import warnings

NULL = robjects.NULL

ggplot2 = importr('ggplot2', on_conflict="warn")
ggplot2 = WeakPackage(ggplot2._env,
                      ggplot2.__rname__,
                      translation=ggplot2._translation,
                      exported_names=ggplot2._exported_names,
                      on_conflict="warn",
                      version=ggplot2.__version__,
                      symbol_r2python=ggplot2._symbol_r2python,
                      symbol_check_after=ggplot2._symbol_check_after)

TARGET_VERSION = '2.2.1'
if ggplot2.__version__ != TARGET_VERSION:
   warnings.warn('This was designed againt ggplot2 version %s but you have %s' % (TARGET_VERSION, ggplot2.__version__))
ggplot2_env = robjects.baseenv['as.environment']('package:ggplot2')

StrVector = robjects.StrVector

def as_symbol(x):
    res = rinterface.parse(x)
    return res

[docs]class GGPlot(robjects.RObject): """ A Grammar of Graphics Plot. GGPlot instances can be added to one an other in order to construct the final plot (the method `__add__()` is implemented). """ _constructor = ggplot2._env['ggplot'] _rprint = ggplot2._env['print.ggplot'] _add = ggplot2._env['%+%']
[docs] @classmethod def new(cls, data): """ Constructor for the class GGplot. """ data = conversion.py2ri(data) res = cls(cls._constructor(data)) return res
def plot(self, vp = robjects.constants.NULL): self._rprint(self, vp = vp) def __add__(self, obj): res = self._add(self, obj) if res.rclass[0] != 'gg': raise ValueError("Added object did not give a ggplot result (get class '%s')." % res.rclass[0]) return self.__class__(res)
[docs] def save(self, filename, **kwargs): """ Save the plot ( calls R's `ggplot2::ggsave()` ) """ ggplot2.ggsave(filename=filename, plot=self, **kwargs)
ggplot = GGPlot.new
[docs]class Aes(robjects.Vector): """ Aesthetics mapping, using expressions rather than string (this is the most common form when using the package in R - it might be easier to use AesString when working in Python using rpy2 - see class AesString in this Python module). """ _constructor = ggplot2_env['aes']
[docs] @classmethod def new(cls, **kwargs): """Constructor for the class Aes.""" new_kwargs = copy.copy(kwargs) for k,v in kwargs.items(): new_kwargs[k] = as_symbol(v) res = cls(cls._constructor(**new_kwargs)) return res
aes = Aes.new
[docs]class AesString(robjects.Vector): """ Aesthetics mapping, using strings rather than expressions (the later being most common form when using the package in R - see class Aes in this Python module). This associates dimensions in the data sets (columns in the DataFrame), possibly with a transformation applied on-the-fly (e.g., "log(value)", or "cost / benefits") to graphical "dimensions" in a chosen graphical representation (e.g., x-axis, color of points, size, etc...). Not all graphical representations have all dimensions. Refer to the documentation of ggplot2, online tutorials, or Hadley's book for more details. """ _constructor = ggplot2_env['aes_string']
[docs] @classmethod def new(cls, **kwargs): """Constructor for the class AesString.""" res = cls(cls._constructor(**kwargs)) return res
aes_string = AesString.new
[docs]class Layer(robjects.RObject): """ At this level, aesthetics mapping can (should ?) be specified (see Aes and AesString). """ _constructor = ggplot2_env['layer'] #_dollar = proto_env["$.proto"]
[docs] @classmethod def new(cls, *args, **kwargs): """ Constructor for the class Layer. """ for i, elt in enumerate(args): args[i] = conversion.py2ro(elt) for k in kwargs: kwargs[k] = conversion.py2ro(kwargs[k]) res = cls(cls.contructor)(*args, **kwargs) return res
layer = Layer.new class GBaseObject(robjects.RObject): @classmethod def new(*args, **kwargs): args_list = list(args) cls = args_list.pop(0) res = cls(cls._constructor(*args_list, **kwargs)) return res
[docs]class Stat(GBaseObject): """ A "statistical" processing of the data in order to make a plot, or a plot element. This is an abstract class; material classes are called Stat* (e.g., StatAbline, StatBin, etc...). """ pass
[docs]class StatBin(Stat): """ Bin data. """ _constructor = ggplot2_env['stat_bin']
stat_bin = StatBin.new
[docs]class StatBin2D(Stat): """ 2D binning of data into squares/rectangles. """ try: _constructor = ggplot2_env['stat_bin_2d'] except: # fallback for versions of ggplot2 < 2.0 _constructor = ggplot2_env['stat_bin2d']
stat_bin2d = StatBin2D.new stat_bin_2d=StatBin2D.new
[docs]class StatBinhex(Stat): """ 2D binning of data into hexagons. """ try: _constructor = ggplot2_env['stat_bin_hex'] except: # fallback for versions of ggplot2 < 2.0 _constructor = ggplot2_env['stat_binhex']
stat_binhex = StatBinhex.new stat_bin_hex=StatBinhex.new
[docs]class StatBoxplot(Stat): """ Components of box and whisker plot. """ _constructor = ggplot2_env['stat_boxplot']
stat_boxplot = StatBoxplot.new
[docs]class StatContour(Stat): """ Contours of 3D data. """ _constructor = ggplot2_env['stat_contour']
stat_contour = StatContour.new
[docs]class StatDensity(Stat): """ 1D density estimate """ _constructor = ggplot2_env['stat_density']
stat_density = StatDensity.new
[docs]class StatDensity2D(Stat): """ 2D density estimate """ try: _constructor = ggplot2_env['stat_density_2d'] except: _constructor = ggplot2_env['stat_density2d']
stat_density2d = StatDensity2D.new stat_density_2d=StatDensity2D.new
[docs]class StatFunction(Stat): """ Superimpose a function """ _constructor = ggplot2_env['stat_function']
stat_function = StatFunction.new
[docs]class StatIdentity(Stat): """ Identity function """ _constructor = ggplot2_env['stat_identity']
stat_identity = StatIdentity.new
[docs]class StatQQ(Stat): """ Calculation for quantile-quantile plot. """ _constructor = ggplot2_env['stat_qq']
stat_qq = StatQQ.new
[docs]class StatQuantile(Stat): """ Continuous quantiles """ _constructor = ggplot2_env['stat_quantile']
stat_quantile = StatQuantile.new
[docs]class StatSmooth(Stat): """ Smoothing function """ _constructor = ggplot2_env['stat_smooth']
stat_smooth = StatSmooth.new
[docs]class StatSpoke(Stat): """ Convert angle and radius to xend and yend """ _constructor = ggplot2_env['stat_spoke']
stat_spoke = StatSpoke.new
[docs]class StatSum(Stat): """ Sum unique values. Useful when overplotting. """ _constructor = ggplot2_env['stat_sum']
stat_sum = StatSum.new
[docs]class StatSummary(Stat): """ Summarize values for y at every unique value for x""" _constructor = ggplot2_env['stat_summary']
stat_summary = StatSummary.new
[docs]class StatSummary2D(Stat): """ Summarize values for y at every unique value for x""" try: _constructor = ggplot2_env['stat_summary_2d'] except: _constructor = ggplot2_env['stat_summary2d']
stat_summary2d = StatSummary2D.new stat_summary_2d = StatSummary2D.new
[docs]class StatUnique(Stat): """ Remove duplicates. """ _constructor = ggplot2_env['stat_unique']
stat_unique = StatUnique.new
[docs]class Coord(GBaseObject): """ Coordinates """ pass
[docs]class CoordFixed(Coord): """ Cartesian coordinates with fixed relationship (that is fixed ratio between units in axes). CoordEquel seems to be identical to this class.""" _constructor = ggplot2_env['coord_fixed']
coord_fixed = CoordFixed.new
[docs]class CoordCartesian(Coord): """ Cartesian coordinates. """ _constructor = ggplot2_env['coord_cartesian']
coord_cartesian = CoordCartesian.new
[docs]class CoordEqual(Coord): """ This class seems to be identical to CoordFixed. """ _constructor = ggplot2_env['coord_equal']
coord_equal = CoordEqual.new
[docs]class CoordFlip(Coord): """ Flip horizontal and vertical coordinates. """ _constructor = ggplot2_env['coord_flip']
coord_flip = CoordFlip.new
[docs]class CoordMap(Coord): """ Map projections. """ _constructor = ggplot2_env['coord_map']
coord_map = CoordMap.new
[docs]class CoordPolar(Coord): """ Polar coordinates. """ _constructor = ggplot2_env['coord_polar']
coord_polar = CoordPolar.new
[docs]class CoordTrans(Coord): """ Apply transformations (functions) to a cartesian coordinate system. """ _constructor = ggplot2_env['coord_trans']
coord_trans = CoordTrans.new
[docs]class Facet(GBaseObject): """ Panels """ pass
[docs]class FacetGrid(Facet): """ Panels in a grid. """ _constructor = ggplot2_env['facet_grid']
facet_grid = FacetGrid.new
[docs]class FacetWrap(Facet): """ Sequence of panels in a 2D layout """ _constructor = ggplot2_env['facet_wrap']
facet_wrap = FacetWrap.new class Geom(GBaseObject): pass class GeomAbline(Geom): _constructor = ggplot2_env['geom_abline'] geom_abline = GeomAbline.new class GeomArea(Geom): _constructor = ggplot2_env['geom_area'] geom_area = GeomArea.new class GeomBar(Geom): _constructor = ggplot2_env['geom_bar'] geom_bar = GeomBar.new class GeomBin2D(Geom): _constructor = ggplot2_env['geom_bin2d'] geom_bin2d = GeomBin2D.new class GeomBlank(Geom): _constructor = ggplot2_env['geom_blank'] geom_blank = GeomBlank.new class GeomBoxplot(Geom): _constructor = ggplot2_env['geom_boxplot'] geom_boxplot = GeomBoxplot.new class GeomContour(Geom): _constructor = ggplot2_env['geom_contour'] geom_contour = GeomContour.new class GeomCrossBar(Geom): _constructor = ggplot2_env['geom_crossbar'] geom_crossbar = GeomCrossBar.new class GeomDensity(Geom): _constructor = ggplot2_env['geom_density'] geom_density = GeomDensity.new class GeomDensity2D(Geom): try: _constructor = ggplot2_env['geom_density_2d'] except: _constructor = ggplot2_env['geom_density2d'] geom_density2d = GeomDensity2D.new geom_density_2d = GeomDensity2D.new class GeomDotplot(Geom): _constructor = ggplot2_env['geom_dotplot'] geom_dotplot = GeomDotplot.new class GeomErrorBar(Geom): _constructor = ggplot2_env['geom_errorbar'] geom_errorbar = GeomErrorBar.new class GeomErrorBarH(Geom): _constructor = ggplot2_env['geom_errorbarh'] geom_errorbarh = GeomErrorBarH.new class GeomFreqPoly(Geom): _constructor = ggplot2_env['geom_freqpoly'] geom_freqpoly = GeomFreqPoly.new class GeomHex(Geom): _constructor = ggplot2_env['geom_hex'] geom_hex = GeomHex.new class GeomHistogram(Geom): _constructor = ggplot2_env['geom_histogram'] geom_histogram = GeomHistogram.new class GeomHLine(Geom): _constructor = ggplot2_env['geom_hline'] geom_hline = GeomHLine.new class GeomJitter(Geom): _constructor = ggplot2_env['geom_jitter'] geom_jitter = GeomJitter.new class GeomLine(Geom): _constructor = ggplot2_env['geom_line'] geom_line = GeomLine.new class GeomLineRange(Geom): _constructor = ggplot2_env['geom_linerange'] geom_linerange = GeomLineRange.new class GeomPath(Geom): _constructor = ggplot2_env['geom_path'] geom_path = GeomPath.new class GeomPoint(Geom): _constructor = ggplot2_env['geom_point'] geom_point = GeomPoint.new class GeomPointRange(Geom): _constructor = ggplot2_env['geom_pointrange'] geom_pointrange = GeomPointRange.new class GeomPolygon(Geom): _constructor = ggplot2_env['geom_polygon'] geom_polygon = GeomPolygon.new class GeomQuantile(Geom): _constructor = ggplot2_env['geom_quantile'] geom_quantile = GeomQuantile.new class GeomRaster(Geom): _constructor = ggplot2_env['geom_raster'] geom_raster = GeomRaster.new class GeomRect(Geom): _constructor = ggplot2_env['geom_rect'] geom_rect = GeomRect.new class GeomRibbon(Geom): _constructor = ggplot2_env['geom_ribbon'] geom_ribbon = GeomRibbon.new class GeomRug(Geom): _constructor = ggplot2_env['geom_rug'] geom_rug = GeomRug.new class GeomSegment(Geom): _constructor = ggplot2_env['geom_segment'] geom_segment = GeomSegment.new class GeomSmooth(Geom): _constructor = ggplot2_env['geom_smooth'] geom_smooth = GeomSmooth.new
[docs]class GeomSpoke(Geom): """ Convert angle and radius to xend and yend """ _constructor = ggplot2_env['geom_spoke']
geom_spoke = GeomSpoke.new class GeomStep(Geom): _constructor = ggplot2_env['geom_step'] geom_step = GeomStep.new class GeomText(Geom): _constructor = ggplot2_env['geom_text'] geom_text = GeomText.new class GeomTile(Geom): _constructor = ggplot2_env['geom_tile'] geom_tile = GeomTile.new class GeomVLine(Geom): _constructor = ggplot2_env['geom_vline'] geom_vline = GeomVLine.new class Position(GBaseObject): pass class PositionDodge(Position): _constructor = ggplot2_env['position_dodge'] position_dodge = PositionDodge.new class PositionFill(Position): _constructor = ggplot2_env['position_fill'] position_fill = PositionFill.new class PositionJitter(Position): _constructor = ggplot2_env['position_jitter'] position_jitter = PositionJitter.new class PositionStack(Position): _constructor = ggplot2_env['position_stack'] position_stack = PositionStack.new class Scale(GBaseObject): pass class ScaleAlpha(Scale): _constructor = ggplot2_env['scale_alpha'] scale_alpha = ScaleAlpha.new class ScaleColour(Scale): pass class ScaleDiscrete(Scale): pass class ScaleLinetype(Scale): _constructor = ggplot2_env['scale_linetype'] scale_linetype = ScaleLinetype.new class ScaleShape(Scale): _constructor = ggplot2_env['scale_shape'] scale_shape = ScaleShape.new class ScaleSize(Scale): _constructor = ggplot2_env['scale_size'] scale_size = ScaleSize.new class ScaleShapeDiscrete(Scale): _constructor = ggplot2_env['scale_shape_discrete'] scale_shape_discrete = ScaleShapeDiscrete.new class ScaleFill(Scale): pass class ScaleX(Scale): pass class ScaleY(Scale): pass # class Limits(Scale): # _constructor = ggplot2_env['limits'] # limits = Limits.new class XLim(Scale): _constructor = ggplot2_env['xlim'] xlim = XLim.new class YLim(Scale): _constructor = ggplot2_env['ylim'] ylim = YLim.new class ScaleXContinuous(ScaleX): _constructor = ggplot2_env['scale_x_continuous'] scale_x_continuous = ScaleXContinuous.new class ScaleYContinuous(ScaleY): _constructor = ggplot2_env['scale_y_continuous'] scale_y_continuous = ScaleYContinuous.new class ScaleXDiscrete(ScaleX): _constructor = ggplot2_env['scale_x_discrete'] scale_x_discrete = ScaleXDiscrete.new class ScaleYDiscrete(ScaleY): _constructor = ggplot2_env['scale_y_discrete'] scale_y_discrete = ScaleYDiscrete.new class ScaleXDate(ScaleX): _constructor = ggplot2_env['scale_x_date'] scale_x_date = ScaleXDate.new class ScaleYDate(ScaleY): _constructor = ggplot2_env['scale_y_date'] scale_y_date = ScaleYDate.new class ScaleXDatetime(ScaleX): _constructor = ggplot2_env['scale_x_datetime'] scale_x_datetime = ScaleXDatetime.new class ScaleYDatetime(ScaleY): _constructor = ggplot2_env['scale_y_datetime'] scale_y_datetime = ScaleYDatetime.new class ScaleXLog10(ScaleX): _constructor = ggplot2_env['scale_x_log10'] scale_x_log10 = ScaleXLog10.new class ScaleYLog10(ScaleY): _constructor = ggplot2_env['scale_y_log10'] scale_y_log10 = ScaleYLog10.new class ScaleXReverse(ScaleX): _constructor = ggplot2_env['scale_x_reverse'] scale_x_reverse = ScaleXReverse.new class ScaleYReverse(ScaleY): _constructor = ggplot2_env['scale_y_reverse'] scale_y_reverse = ScaleYReverse.new class ScaleXSqrt(ScaleX): _constructor = ggplot2_env['scale_x_sqrt'] scale_x_sqrt = ScaleXSqrt.new class ScaleYSqrt(ScaleY): _constructor = ggplot2_env['scale_y_sqrt'] scale_y_sqrt = ScaleYSqrt.new class ScaleColourBrewer(ScaleColour): _constructor = ggplot2_env['scale_colour_brewer'] scale_colour_brewer = ScaleColourBrewer.new scale_color_brewer = scale_colour_brewer class ScaleColourContinuous(ScaleColour): _constructor = ggplot2_env['scale_colour_continuous'] scale_colour_continuous = ScaleColourContinuous.new scale_color_continuous = scale_colour_continuous class ScaleColourDiscrete(ScaleColour): _constructor = ggplot2_env['scale_colour_discrete'] scale_colour_discrete = ScaleColourDiscrete.new scale_color_discrete = scale_colour_discrete class ScaleColourGradient(ScaleColour): _constructor = ggplot2_env['scale_colour_gradient'] scale_colour_gradient = ScaleColourGradient.new scale_color_gradient = scale_colour_gradient class ScaleColourGradient2(ScaleColour): _constructor = ggplot2_env['scale_colour_gradient2'] scale_colour_gradient2 = ScaleColourGradient2.new scale_color_gradient2 = scale_colour_gradient2 class ScaleColourGradientN(ScaleColour): _constructor = ggplot2_env['scale_colour_gradientn'] scale_colour_gradientn = ScaleColourGradientN.new scale_color_gradientn = scale_colour_gradientn class ScaleColourGrey(ScaleColour): _constructor = ggplot2_env['scale_colour_grey'] scale_colour_grey = ScaleColourGrey.new scale_color_grey = scale_colour_grey class ScaleColourHue(ScaleColour): _constructor = ggplot2_env['scale_colour_hue'] scale_colour_hue = ScaleColourHue.new scale_color_hue = scale_colour_hue class ScaleColourIdentity(ScaleColour): _constructor = ggplot2_env['scale_colour_identity'] scale_colour_identity = ScaleColourIdentity.new scale_color_identity = scale_colour_identity class ScaleColourManual(ScaleColour): _constructor = ggplot2_env['scale_colour_manual'] scale_colour_manual = ScaleColourManual.new scale_color_manual = scale_colour_manual class ScaleFillBrewer(ScaleFill): _constructor = ggplot2_env['scale_fill_brewer'] scale_fill_brewer = ScaleFillBrewer.new class ScaleFillContinuous(ScaleFill): _constructor = ggplot2_env['scale_fill_continuous'] scale_fill_continuous = ScaleFillContinuous.new class ScaleFillDiscrete(ScaleFill): _constructor = ggplot2_env['scale_fill_discrete'] scale_fill_discrete = ScaleFillDiscrete.new class ScaleFillGradient(ScaleFill): _constructor = ggplot2_env['scale_fill_gradient'] scale_fill_gradient = ScaleFillGradient.new class ScaleFillGradient2(ScaleFill): _constructor = ggplot2_env['scale_fill_gradient2'] scale_fill_gradient2 = ScaleFillGradient2.new class ScaleFillGradientN(ScaleFill): _constructor = ggplot2_env['scale_fill_gradientn'] scale_fill_gradientn = ScaleFillGradientN.new class ScaleFillGrey(ScaleFill): _constructor = ggplot2_env['scale_fill_grey'] scale_fill_grey = ScaleFillGrey.new class ScaleFillHue(ScaleFill): _constructor = ggplot2_env['scale_fill_hue'] scale_fill_hue = ScaleFillHue.new class ScaleFillIdentity(ScaleFill): _constructor = ggplot2_env['scale_fill_identity'] scale_fill_identity = ScaleFillIdentity.new class ScaleFillManual(ScaleFill): _constructor = ggplot2_env['scale_fill_manual'] scale_fill_manual = ScaleFillManual.new class ScaleLinetypeContinuous(ScaleLinetype): _constructor = ggplot2_env['scale_linetype_continuous'] scale_linetype_continuous = ScaleLinetypeContinuous.new class ScaleLinetypeDiscrete(ScaleLinetype): _constructor = ggplot2_env['scale_linetype_discrete'] scale_linetype_discrete = ScaleLinetypeDiscrete.new class ScaleLinetypeManual(ScaleLinetype): _constructor = ggplot2_env['scale_linetype_manual'] scale_linetype_manual = ScaleLinetypeManual.new class ScaleShapeManual(ScaleShape): _constructor = ggplot2_env['scale_shape_manual'] scale_shape_manual = ScaleShapeManual.new guides = ggplot2.guides guide_colorbar = ggplot2.guide_colorbar guide_colourbar = ggplot2.guide_colourbar guide_legend = ggplot2.guide_legend class Options(robjects.Vector): def __init__(self, obj): self.__sexp__ = obj.__sexp__ def __repr__(self): s = '<instance of %s : %i>' %(type(self), id(self)) return s class Element(Options): pass class ElementText(Element): _constructor = ggplot2.element_text @classmethod def new(cls, family = "", face = "plain", colour = "black", size = 10, hjust = 0.5, vjust = 0.5, angle = 0, lineheight = 1.1, color = NULL): res = cls(cls._constructor(family = family, face = face, colour = colour, size = size, hjust = hjust, vjust = vjust, angle = angle, lineheight = lineheight)) return res element_text = ElementText.new class ElementRect(Element): _constructor = ggplot2.element_rect @classmethod def new(cls, fill = NULL, colour = NULL, size = NULL, linetype = NULL, color = NULL): res = cls(cls._constructor(fill = fill, colour = colour, size = size, linetype = linetype, color = color)) return res element_rect = ElementRect.new class Labs(Options): _constructor = ggplot2.labs @classmethod def new(cls, **kwargs): res = cls(cls._constructor(**kwargs)) return res labs = Labs.new class Theme(Options): pass class ElementBlank(Theme): _constructor = ggplot2.element_blank @classmethod def new(cls): res = cls(cls._constructor()) return res element_blank = ElementBlank.new theme_get = ggplot2.theme_get class ThemeGrey(Theme): _constructor = ggplot2.theme_grey @classmethod def new(cls, base_size = 12): res = cls(cls._constructor(base_size = base_size)) return res theme_grey = ThemeGrey.new class ThemeClassic(Theme): _constructor = ggplot2.theme_classic @classmethod def new(cls, base_size = 12, base_family = ""): res = cls(cls._constructor(base_size = base_size, base_family = base_family)) return res theme_classic = ThemeClassic.new class ThemeDark(Theme): _constructor = ggplot2.theme_dark @classmethod def new(cls, base_size = 12, base_family = ""): res = cls(cls._constructor(base_size = base_size, base_family = base_family)) return res theme_dark = ThemeDark.new class ThemeLight(Theme): _constructor = ggplot2.theme_light @classmethod def new(cls, base_size = 12, base_family = ""): res = cls(cls._constructor(base_size = base_size, base_family = base_family)) return res theme_light = ThemeLight.new class ThemeBW(Theme): _constructor = ggplot2.theme_bw @classmethod def new(cls, base_size = 12): res = cls(cls._constructor(base_size = base_size)) return res theme_bw = ThemeBW.new class ThemeGray(Theme): _constructor = ggplot2.theme_gray @classmethod def new(cls, base_size = 12): res = cls(cls._constructor(base_size = base_size)) return res theme_gray = ThemeGray.new theme_grey = theme_gray class ThemeMinimal(Theme): _constructor = ggplot2.theme_minimal @classmethod def new(cls, base_size = 12, base_family = ""): res = cls(cls._constructor(base_size = base_size, base_family = base_family)) return res theme_minimal = ThemeMinimal.new class ThemeLinedraw(Theme): _constructor = ggplot2.theme_linedraw @classmethod def new(cls, base_size=12, base_family=""): res = cls(cls._constructor(base_size=base_size, base_family=base_family)) return res theme_linedraw = ThemeLinedraw.new class ThemeVoid(Theme): _constructor = ggplot2.theme_void @classmethod def new(cls, base_size = 12, base_family = ""): res = cls(cls._constructor(base_size = base_size, base_family = base_family)) return res theme_void = ThemeVoid.new #theme_render theme_set = ggplot2.theme_set theme_update = ggplot2.theme_update gplot = ggplot2.qplot map_data = ggplot2.map_data theme = ggplot2_env['theme'] ggtitle = ggplot2.ggtitle original_ri2ro = conversion.ri2ro def ggplot2_conversion(robj): pyobj = original_ri2ro(robj) try: rcls = pyobj.rclass except AttributeError: # conversion lead to something that is no # longer an R object return pyobj if (rcls is not None) and ('gg' in rcls): pyobj = GGPlot(pyobj) return pyobj conversion.ri2ro = ggplot2_conversion