lets-plot 4.8.1rc1__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

lets_plot/plot/__init__.py

@@ -0,0 +1,64 @@
+#
+# Copyright (c) 2019. JetBrains s.r.o.
+# Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+from .annotation import *
+from .coord import *
+from .core import *
+from .expand_limits_ import *
+from .facet import *
+from .font_features import *
+from .geom import *
+from .geom_extras import *
+from .geom_function_ import *
+from .geom_imshow_ import *
+from .geom_livemap_ import *
+from .ggbunch_ import *
+from .gggrid_ import *
+from .ggtb_ import *
+from .guide import *
+from .label import *
+from .marginal_layer import *
+from .plot import *
+from .pos import *
+from .sampling import *
+from .scale import *
+from .scale_colormap_mpl import *
+from .scale_convenience import *
+from .scale_identity_ import *
+from .scale_position import *
+from .stat import *
+from .theme_ import *
+from .theme_set import *
+from .tooltip import *
+
+__all__ = (coord.__all__ +
+           core.__all__ +
+           facet.__all__ +
+           geom.__all__ +
+           geom_extras.__all__ +
+           geom_function_.__all__ +
+           geom_imshow_.__all__ +
+           geom_livemap_.__all__ +
+           guide.__all__ +
+           label.__all__ +
+           plot.__all__ +
+           pos.__all__ +
+           sampling.__all__ +
+           scale.__all__ +
+           scale_colormap_mpl.__all__ +
+           scale_convenience.__all__ +
+           scale_identity_.__all__ +
+           scale_position.__all__ +
+           stat.__all__ +
+           theme_.__all__ +
+           theme_set.__all__ +
+           tooltip.__all__ +
+           annotation.__all__ +
+           marginal_layer.__all__ +
+           font_features.__all__ +
+           ggbunch_.__all__ +
+           gggrid_.__all__ +
+           ggtb_.__all__ +
+           expand_limits_.__all__
+           )

lets_plot/plot/_global_theme.py

@@ -0,0 +1,14 @@
+#
+#  Copyright (c) 2024. JetBrains s.r.o.
+#  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+_global_theme = None
+
+
+def _set_global_theme(theme):
+    global _global_theme
+    _global_theme = theme
+
+
+def _get_global_theme():
+    return _global_theme

lets_plot/plot/annotation.py

@@ -0,0 +1,290 @@
+#  Copyright (c) 2022. JetBrains s.r.o.
+#  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+
+from typing import List
+
+from lets_plot.plot.core import FeatureSpec, _filter_none
+
+#
+# Annotations
+#
+
+__all__ = ['layer_labels']
+
+
+class layer_labels(FeatureSpec):
+    """
+    Configure annotations for geometry layers.
+
+    Annotations are currently supported for bar, pie, and crossbar geometry
+    layers. This class provides methods to customize the appearance and
+    content of text labels displayed on these geometries.
+
+    Notes
+    -----
+    By default, annotation text color is automatically selected for optimal
+    contrast: white text appears on darker filled geometries, and black text
+    appears on lighter filled geometries.
+
+    The text color can be manually specified using:
+    ``theme(label_text=element_text(color=...))``
+
+    Alternatively, the ``inherit_color()`` method can be used to override both
+    automatic and manual color settings, making the annotation text use the
+    geometry's ``color`` aesthetic instead.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 6
+
+        from lets_plot import *
+        LetsPlot.setup_html()
+        data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+        ggplot(data) + geom_pie(aes(slice='value', fill='name'), size=15, hole=0.4, \\
+                                stat='identity', tooltips='none', \\
+                                labels=layer_labels().line('@value'))
+
+    """
+
+    def __init__(self, variables: List[str] = None):
+        """
+        Initialize self.
+
+        Parameters
+        ----------
+        variables : list of str
+            Variable names to place in the annotation with default formatting.
+
+        """
+
+        self._formats: List = []
+        self._lines: List = None
+        self._variables = variables
+        self._size = None
+        self._useLayerColor = None
+        super().__init__('labels', name=None)
+
+    def as_dict(self):
+        """
+        Return a dictionary of all properties of the object.
+
+        Returns
+        -------
+        dict
+            Dictionary of properties.
+
+        Examples
+        --------
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 6
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            layer_labels().format('@{..prop..}', '.0%') \\
+                         .line('@name') \\
+                         .line('(@{..prop..})') \\
+                         .as_dict()
+
+        """
+        d = super().as_dict()
+        d['formats'] = self._formats
+        d['lines'] = self._lines
+        d['variables'] = self._variables
+        d['annotation_size'] = self._size
+        d['use_layer_color'] = self._useLayerColor
+        return _filter_none(d)
+
+    def format(self, field=None, format=None):
+        """
+        Define the format for displaying the value.
+        This format will be applied to the corresponding value specified in the 'line' template.
+
+        Parameters
+        ----------
+        field : str
+            Name of an aesthetic or variable that would be formatted.
+            The field name starts with a '^' prefix for aesthetics,
+            the variable name starts with a '@' prefix or without any prefix.
+        format : str
+            Formatting specification. The format contains a number format ('1.f'),
+            a string template ('{.1f}') or a date/time format ('%d.%m.%y').
+            The numeric format for non-numeric value will be ignored.
+            If you need to include a brace character in the literal text,
+            it can be escaped by doubling: ``{{`` and ``}}``.
+
+        Returns
+        -------
+        ``layer_labels``
+            Annotations specification.
+
+        Notes
+        -----
+        For more info see `Formatting <https://lets-plot.org/python/pages/formats.html>`__.
+
+        Examples
+        --------
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 7
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+            ggplot(data) + geom_pie(aes(fill=as_discrete('name', order_by='..count..'), weight='value'), \\
+                                    size=15, tooltips='none', \\
+                                    labels=layer_labels(['..proppct..']) \\
+                                                  .format('..proppct..', '{.1f}%'))
+
+        |
+
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 7, 9, 11, 13
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+            ggplot(data) + geom_pie(aes(fill=as_discrete('name', order_by='..count..', order=1), weight='value'), \\
+                                    size=15, tooltips='none', \\
+                                    labels=layer_labels() \\
+                                                    .format('^fill', '{{{}}}') \\
+                                                    .line('^fill') \\
+                                                    .format('..count..', 'd') \\
+                                                    .line('@{..count..}') \\
+                                                    .format('..prop..', '.1%') \\
+                                                    .line('@{..prop..}') \\
+                                                    .format('..sum..', 'of {d}') \\
+                                                    .line('@{..sum..}'))
+
+        """
+        self._formats.append({"field": field, "format": format})
+        return self
+
+    def line(self, value):
+        """
+        Add a line of text to the multiline label annotation.
+
+        This method configures one line of text that will be displayed in a
+        multiline label. Multiple calls to this method can be chained to build
+        up a complete multiline annotation.
+
+        Parameters
+        ----------
+        value : str
+            The text content for this line of the annotation. Can include
+            variable and aesthetic references.
+
+        Returns
+        -------
+        ``layer_labels``
+            Annotations specification.
+
+        Notes
+        -----
+        Variables and aesthetics can be accessed via special syntax:
+
+        - ^color for aesthetics,
+        - @x for variable,
+        - @{x + 1} for variable with spaces in the name,
+        - @{x^2 + 1} for variable with spaces and '^' symbol in the name,
+        - @x^2 for variable with '^' symbol in its name.
+
+        Special characters can be escaped:
+
+        - 'x\\\\^2' -> "x^2" (escape ^ with backslash)
+        - '{{x}}' -> "{x}" (escape braces by doubling)
+
+        Examples
+        --------
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 8-11
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+            ggplot(data) + geom_pie(aes(fill='name', weight='value'), size=15, \\
+                                    tooltips='none', \\
+                                    labels=layer_labels()\\
+                                          .format('..prop..', '.1%')\\
+                                          .line('"^fill"')\\
+                                          .line('@{..count..}')\\
+                                          .line('@{..prop..}')\\
+                                          .line('(@{..sum..})'))
+
+        """
+        if self._lines is None:
+            self._lines = []
+        self._lines.append(value)
+        return self
+
+    def size(self, value):
+        """
+        Set the text size for the annotation.
+
+        Parameters
+        ----------
+        value : float
+            The text size value for the annotation.
+
+        Returns
+        -------
+        ``layer_labels``
+            Annotations specification.
+
+        Examples
+        --------
+
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 7
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+            ggplot(data) + geom_pie(aes(slice='value', fill='name'), size=15, hole=0.4, \\
+                                    stat='identity', tooltips='none', \\
+                                    labels=layer_labels().line('@value')
+                                                             .size(25))
+
+        """
+
+        self._size = value
+        return self
+
+    def inherit_color(self):
+        """
+        Use the layer's color for the annotation text.
+
+        When enabled, the annotation text will inherit the color from the
+        layer it's associated with, rather than using a default or
+        explicitly set color.
+
+        Returns
+        -------
+        ``layer_labels``
+            Annotations specification.
+
+        Examples
+        --------
+
+        .. jupyter-execute::
+            :linenos:
+            :emphasize-lines: 8
+
+            from lets_plot import *
+            LetsPlot.setup_html()
+            data = {'name': ['a', 'b', 'c', 'd', 'b'], 'value': [40, 90, 10, 50, 20 ]}
+            ggplot(data) + geom_pie(aes(slice='value', color='name'), alpha=0, size=15, hole=0.4, \\
+                                    stroke=5, spacer_color='pen', \\
+                                    stat='identity', tooltips='none', \\
+                                    labels=layer_labels().line('@value')
+                                                         .inherit_color())
+
+        """
+
+        self._useLayerColor = True
+        return self

lets_plot/plot/coord.py

@@ -0,0 +1,242 @@
+#
+# Copyright (c) 2019. JetBrains s.r.o.
+# Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+from .core import FeatureSpec
+
+#
+# Coordinate Systems
+#
+__all__ = ['coord_cartesian',
+           'coord_fixed',
+           'coord_map',
+           'coord_flip',
+           'coord_polar',
+           ]
+
+
+def coord_cartesian(xlim=None, ylim=None, flip=False):
+    """
+    The Cartesian coordinate system is the most familiar and common type of coordinate system.
+    Setting limits on the coordinate system will zoom the plot like you're looking at it with a magnifying glass.
+    It does not change the underlying data as setting limits on a scale does.
+
+    Parameters
+    ----------
+    xlim : list
+        Limits (2 elements) for the x axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    ylim : list
+        Limits (2 elements) for the y axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    flip : bool
+        Flip the coordinate system axis so that horizontal axis becomes vertical and vice versa.
+
+    Returns
+    -------
+    ``FeatureSpec``
+        Coordinate system specification.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7
+
+        from lets_plot import *
+        LetsPlot.setup_html()
+        data = {'x': [0, 8, 12, 17, 20, 26],
+                'y': [0, 8, 12, 17, 20, 26],
+                'g': ['a', 'a', 'b', 'b', 'c', 'c']}
+        ggplot(data) + geom_line(aes(x='x', y='y', group='g')) + \\
+            coord_cartesian(xlim=(4, 23), ylim=(3, 22))
+
+    """
+
+    return _coord('cartesian', xlim=xlim, ylim=ylim, flip=flip)
+
+
+def coord_fixed(ratio=1., xlim=None, ylim=None, flip=False):
+    """
+    A fixed scale coordinate system forces a specified ratio between the physical representations of data units on the axes.
+
+    Parameters
+    ----------
+    ratio : float
+        The ratio represents the number of units on the y-axis equivalent to one unit on the x-axis.
+        ratio = 1, ensures that one unit on the x-axis is the same length as one unit on the y-axis.
+        Ratios higher than one make units on the y-axis longer than units on the x-axis, and vice versa.
+    xlim : list
+        Limits (2 elements) for the x axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    ylim : list
+        Limits (2 elements) for the y axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    flip : bool
+        Flip the coordinate system axis so that horizontal axis becomes vertical and vice versa.
+
+    Returns
+    -------
+    ``FeatureSpec``
+        Coordinate system specification.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 9
+
+        import numpy as np
+        from lets_plot import *
+        LetsPlot.setup_html()
+        n = 30
+        np.random.seed(42)
+        x = np.random.uniform(-1, 1, size=n)
+        y = 25 * x ** 2 + np.random.normal(size=n)
+        ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
+            geom_point() + coord_fixed(ratio=.2, ylim=(7, 20))
+
+    """
+
+    return _coord('fixed', ratio=ratio, xlim=xlim, ylim=ylim, flip=flip)
+
+
+def coord_map(xlim=None, ylim=None, flip=False):
+    """
+    Project a portion of the earth, which is approximately spherical,
+    onto a flat 2D plane.
+    Map projections generally do not preserve straight lines, so this requires considerable computation.
+
+    Parameters
+    ----------
+    xlim : list
+        Limits (2 elements) for the x axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    ylim : list
+        Limits (2 elements) for the y axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    flip : bool
+        Flip the coordinate system axis so that horizontal axis becomes vertical and vice versa.
+
+    Returns
+    -------
+    ``FeatureSpec``
+        Coordinate system specification.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 6
+
+        from lets_plot import *
+        from lets_plot.geo_data import *
+        LetsPlot.setup_html()
+        us = geocode_states('US-48').get_boundaries(4)
+        ggplot() + geom_map(map=us, fill='gray', color='white') + \\
+            coord_map(xlim=(-130, -100))
+
+    """
+
+    return _coord('map', xlim=xlim, ylim=ylim, flip=flip)
+
+
+def coord_flip(xlim=None, ylim=None):
+    """
+    Flip axis of default coordinate system so that horizontal axis becomes vertical and vice versa.
+
+    Parameters
+    ----------
+    xlim : list
+        Limits (2 elements) for the x axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    ylim : list
+        Limits (2 elements) for the y axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+
+    Returns
+    -------
+    ``FeatureSpec``
+        Coordinate system specification.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 12
+
+        import numpy as np
+        from lets_plot import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        n = 10
+        x = np.arange(n)
+        y = 1 + np.random.randint(5, size=n)
+        ggplot() + \\
+            geom_bar(aes(x='x', y='y', fill='x'), data={'x': x, 'y': y}, \\
+                     stat='identity', show_legend=False) + \\
+            scale_fill_discrete() + \\
+            coord_flip()
+
+    """
+
+    return _coord('flip', xlim=xlim, ylim=ylim, flip=True)
+
+
+def coord_polar(xlim=None, ylim=None, theta=None, start=None, direction=None, transform_bkgr=None):
+    """
+    Polar coordinate system. It is used for pie charts and polar plots.
+
+    Parameters
+    ----------
+    xlim : list
+        Limits (2 elements) for the x axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    ylim : list
+        Limits (2 elements) for the y axis.
+        1st element defines lower limit, 2nd element defines upper limit.
+        None means no lower / upper bound - depending on the index in list.
+    theta : {'x', 'y'}, default='x'
+        Aesthetic that is used to map angle.
+    start : float, default=0
+        Offset relative to the starting angle (which is 12 o'clock), in radians.
+    direction : {1, -1}, default=1
+        Specify angle direction, 1=clockwise, -1=counter-clockwise.
+    transform_bkgr : bool, default=True
+        If True, the background is transformed to a circle, rectangle otherwise.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 13
+
+        import numpy as np
+        from lets_plot import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        n = 20
+        data = {
+            'v': 1 + np.random.randint(5, size=n)
+        }
+        ggplot(data) + \\
+            geom_bar(aes(fill=as_discrete('v')), size=0, show_legend=False) + \\
+            scale_x_continuous(expand=[0, 0]) + \\
+            scale_y_continuous(expand=[0, 0]) + \\
+            coord_polar(theta='y')
+
+    """
+    return _coord('polar', xlim=xlim, ylim=ylim, theta=theta, start=start, direction=direction, transform_bkgr=transform_bkgr)
+
+
+def _coord(name, **other):
+    return FeatureSpec('coord', name=name, **other)