"""
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
