Merge pull request #16 from kdorr/axis-numeric

Axis numeric

Author: story645

mplaltair/__init__.py

@@ -1,8 +1,8 @@
 import matplotlib
 import altair
-
 from ._convert import _convert
 
+
 def convert(chart):
     """Convert an altair encoding to a Matplotlib figure
 

mplaltair/_axis.py

@@ -0,0 +1,234 @@
+import matplotlib.dates as mdates
+import matplotlib.ticker as ticker
+import numpy as np
+from ._data import _locate_channel_data, _locate_channel_dtype, _locate_channel_scale, _locate_channel_axis, _convert_to_mpl_date
+
+
+def _set_limits(channel, scale):
+    """Set the axis limits on the Matplotlib axis
+
+    Parameters
+    ----------
+    channel : dict
+        The mapping of the channel data and metadata
+    scale : dict
+        The mapping of the scale metadata and the scale data
+    """
+
+    _axis_kwargs = {
+        'x': {'min': 'left', 'max': 'right'},
+        'y': {'min': 'bottom', 'max': 'top'},
+    }
+
+    lims = {}
+
+    if channel['dtype'] == 'quantitative':
+        # determine limits
+        if 'domain' in scale:  # domain takes precedence over zero in Altair
+            if scale['domain'] == 'unaggregated':
+                raise NotImplementedError
+            else:
+                lims[_axis_kwargs[channel['axis']].get('min')] = scale['domain'][0]
+                lims[_axis_kwargs[channel['axis']].get('max')] = scale['domain'][1]
+        elif 'type' in scale and scale['type'] != 'linear':
+            lims = _set_scale_type(channel, scale)
+        else:
+            # Check that a positive minimum is zero if zero is True:
+            if ('zero' not in scale or scale['zero'] == True) and min(channel['data']) > 0:
+                lims[_axis_kwargs[channel['axis']].get('min')] = 0  # quantitative sets min to be 0 by default
+
+            # Check that a negative maximum is zero if zero is True:
+            if ('zero' not in scale or scale['zero'] == True) and max(channel['data']) < 0:
+                lims[_axis_kwargs[channel['axis']].get('max')] = 0
+
+    elif channel['dtype'] == 'temporal':
+        # determine limits
+        if 'domain' in scale:
+            domain = _convert_to_mpl_date(scale['domain'])
+            lims[_axis_kwargs[channel['axis']].get('min')] = domain[0]
+            lims[_axis_kwargs[channel['axis']].get('max')] = domain[1]
+        elif 'type' in scale and scale['type'] != 'time':
+            lims = _set_scale_type(channel, scale)
+
+    else:
+        raise NotImplementedError  # Ordinal and Nominal go here?
+
+    # set the limits
+    if channel['axis'] == 'x':
+        channel['ax'].set_xlim(**lims)
+    else:
+        channel['ax'].set_ylim(**lims)
+
+
+def _set_scale_type(channel, scale):
+    """If the scale is non-linear, change the scale and return appropriate axis limits.
+    The 'linear' and 'time' scale types are not included here because quantitative defaults to 'linear'
+    and temporal defaults to 'time'. The 'utc' and 'sequential' scales are currently not supported.
+
+    Parameters
+    ----------
+    channel : dict
+        The mapping of the channel data and metadata
+    scale : dict
+        The mapping of the scale metadata and the scale data
+
+    Returns
+    -------
+    lims : dict
+        The axis limit mapped to the appropriate axis parameter for scales that change axis limit behavior
+    """
+    lims = {}
+    if scale['type'] == 'log':
+
+        base = 10  # default base is 10 in altair
+        if 'base' in scale:
+            base = scale['base']
+
+        if channel['axis'] == 'x':
+            channel['ax'].set_xscale('log', basex=base)
+            # lower limit: round down to nearest major tick (using log base change rule)
+            lims['left'] = base**np.floor(np.log10(channel['data'].min())/np.log10(base))
+        else:  # y-axis
+            channel['ax'].set_yscale('log', basey=base)
+            # lower limit: round down to nearest major tick (using log base change rule)
+            lims['bottom'] = base**np.floor(np.log10(channel['data'].min())/np.log10(base))
+
+    elif scale['type'] == 'pow' or scale['type'] == 'sqrt':
+        """The 'sqrt' scale is just the 'pow' scale with exponent = 0.5.
+        When Matplotlib gets a power scale, the following should work:
+        
+        exponent = 2  # default exponent value for 'pow' scale
+        if scale['type'] == 'sqrt':
+            exponent = 0.5
+        elif 'exponent' in scale:
+            exponent = scale['exponent']
+
+        if channel['axis'] == 'x':
+            channel['ax'].set_xscale('power_scale', exponent=exponent)
+        else:  # y-axis
+            channel['ax'].set_yscale('power_scale', exponent=exponent)
+        """
+        raise NotImplementedError
+
+    elif scale['type'] == 'utc':
+        raise NotImplementedError
+    elif scale['type'] == 'sequential':
+        raise NotImplementedError("sequential scales used primarily for continuous colors")
+    else:
+        raise NotImplementedError
+    return lims
+
+
+def _set_tick_locator(channel, axis):
+    """Set the tick locator if it needs to vary from the default locator
+
+    Parameters
+    ----------
+    channel : dict
+        The mapping of the channel data and metadata
+    axis : dict
+        The mapping of the axis metadata and the scale data
+    """
+    current_axis = {'x': channel['ax'].xaxis, 'y': channel['ax'].yaxis}
+    if 'values' in axis:
+        if channel['dtype'] == 'temporal':
+            current_axis[channel['axis']].set_major_locator(ticker.FixedLocator(_convert_to_mpl_date(axis.get('values'))))
+        elif channel['dtype'] == 'quantitative':
+            current_axis[channel['axis']].set_major_locator(ticker.FixedLocator(axis.get('values')))
+        else:
+            raise NotImplementedError
+    elif 'tickCount' in axis:
+        current_axis[channel['axis']].set_major_locator(
+            ticker.MaxNLocator(steps=[2, 5, 10], nbins=axis.get('tickCount')+1, min_n_ticks=axis.get('tickCount'))
+        )
+
+
+def _set_tick_formatter(channel, axis):
+    """Set the tick formatter.
+
+
+    Parameters
+    ----------
+    channel : dict
+        The mapping of the channel data and metadata
+    axis : dict
+        The mapping of the axis metadata and the scale data
+
+    Notes
+    -----
+    For quantitative formatting, Matplotlib does not support some format strings that Altair supports.
+    Matplotlib only supports format strings as used by str.format().
+
+    For formatting of temporal data, Matplotlib does not support some format strings that Altair supports (%L, %Q, %s).
+    Matplotlib only supports datetime.strftime formatting for dates.
+    """
+    current_axis = {'x': channel['ax'].xaxis, 'y': channel['ax'].yaxis}
+    format_str = ''
+
+    if 'format' in axis:
+        format_str = axis['format']
+
+    if channel['dtype'] == 'temporal':
+        if not format_str:
+            format_str = '%b %d, %Y'
+
+        current_axis[channel['axis']].set_major_formatter(mdates.DateFormatter(format_str))  # May fail silently
+
+    elif channel['dtype'] == 'quantitative':
+        if format_str:
+            current_axis[channel['axis']].set_major_formatter(ticker.StrMethodFormatter('{x:' + format_str + '}'))
+
+            # Verify that the format string is valid for Matplotlib and exit nicely if not.
+            try:
+                current_axis[channel['axis']].get_major_formatter().__call__(1)
+            except ValueError:
+                raise ValueError("Matplotlib only supports format strings as used by `str.format()`."
+                                 "Some format strings that work in Altair may not work in Matplotlib."
+                                 "Please use a different format string.")
+    else:
+        raise NotImplementedError  # Nominal and Ordinal go here
+
+
+def _set_label_angle(channel, axis):
+    """Set the label angle. TODO: handle axis.labelAngle from Altair
+
+        Parameters
+        ----------
+        channel : dict
+            The mapping of the channel data and metadata
+        axis : dict
+            The mapping of the axis metadata and the scale data
+        """
+    if channel['dtype'] == 'temporal' and channel['axis'] == 'x':
+        for label in channel['ax'].get_xticklabels():
+            # Rotate the labels on the x-axis so they don't run into each other.
+            label.set_rotation(30)
+            label.set_ha('right')
+
+
+def convert_axis(ax, chart):
+    """Convert elements of the altair chart to Matplotlib axis properties
+
+    Parameters
+    ----------
+    ax
+        The Matplotlib axis to be modified
+    chart
+        The Altair chart
+    """
+
+    for channel in chart.to_dict()['encoding']:
+        if channel in ['x', 'y']:
+            chart_info = {'ax': ax, 'axis': channel,
+                          'data': _locate_channel_data(chart, channel),
+                          'dtype': _locate_channel_dtype(chart, channel)}
+            if chart_info['dtype'] == 'temporal':
+                chart_info['data'] = _convert_to_mpl_date(chart_info['data'])
+
+            scale_info = _locate_channel_scale(chart, channel)
+            axis_info = _locate_channel_axis(chart, channel)
+
+            _set_limits(chart_info, scale_info)
+            _set_tick_locator(chart_info, axis_info)
+            _set_tick_formatter(chart_info, axis_info)
+            _set_label_angle(chart_info, axis_info)

mplaltair/_convert.py

@@ -1,5 +1,6 @@
 import matplotlib.dates as mdates
-from ._data import _locate_channel_data, _locate_channel_dtype
+import numpy as np
+from ._data import _locate_channel_data, _locate_channel_dtype, _convert_to_mpl_date
 
 def _allowed_ranged_marks(enc_channel, mark):
     """TODO: DOCS
@@ -120,10 +121,8 @@ def _convert(chart):
         data = _locate_channel_data(chart, channel)
         dtype = _locate_channel_dtype(chart, channel)
         if dtype == 'temporal':
-            try:
-                data = mdates.date2num(data)  # Convert dates to Matplotlib dates
-            except AttributeError:
-                raise
+            data = _convert_to_mpl_date(data)
+
         mapping[_mappings[channel](dtype, data)[0]] = _mappings[channel](dtype, data)[1]
 
     return mapping

mplaltair/_data.py

@@ -1,4 +1,8 @@
 from ._exceptions import ValidationError
+import matplotlib.dates as mdates
+import matplotlib.cbook as cbook
+from datetime import datetime
+import numpy as np
 
 def _locate_channel_dtype(chart, channel):
     """Locates dtype used for each channel
@@ -61,4 +65,120 @@ def _aggregate_channel():
 
 
 def _handle_timeUnit():
-    raise NotImplementedError
+    raise NotImplementedError
+
+
+def _locate_channel_scale(chart, channel):
+    """Locates the channel's scale information.
+
+    Parameters
+    ----------
+    chart
+        The Altair chart
+    channel
+        The Altair channel being examined
+
+    Returns
+    -------
+    A dictionary with the scale information
+    """
+    channel_val = chart.to_dict()['encoding'][channel]
+    if channel_val.get('scale'):
+        return channel_val.get('scale')
+    else:
+        return {}
+
+
+def _locate_channel_axis(chart, channel):
+    """Locates the channel's scale information.
+
+    Parameters
+    ----------
+    chart
+        The Altair chart
+    channel
+        The Altair channel being examined
+
+    Returns
+    -------
+    A dictionary with the axis information
+    """
+    channel_val = chart.to_dict()['encoding'][channel]
+    if channel_val.get('axis'):
+        return channel_val.get('axis')
+    else:
+        return {}
+
+def _convert_to_mpl_date(data):
+    """Converts datetime, datetime64, strings, and Altair DateTime objects to Matplotlib dates.
+
+    Parameters
+    ----------
+    data : datetime.datetime, numpy.datetime64, str, Altair DateTime, or sequences of any of these
+        The data to be converted to a Matplotlib date
+
+    Returns
+    -------
+    new_data : list
+        A list containing the converted date(s)
+    """
+
+    if cbook.iterable(data) and not isinstance(data, str) and not isinstance(data, dict):
+        if len(data) == 0:
+            return []
+        else:
+            return [_convert_to_mpl_date(i) for i in data]
+    else:
+        if isinstance(data, str):  # string format for dates
+            data = mdates.datestr2num(data)
+        elif isinstance(data, np.datetime64):  # sequence of datetimes, datetime64s
+            data = mdates.date2num(data)
+        elif isinstance(data, dict):  # Altair DateTime
+            data = mdates.date2num(_altair_DateTime_to_datetime(data))
+        else:
+            raise TypeError
+        return data
+
+
+def _altair_DateTime_to_datetime(dt):
+    """Convert dictionary representation of an Altair DateTime to datetime object
+
+    Parameters
+    ----------
+    dt : dict
+        The dictionary representation of the Altair DateTime object to be converted.
+
+    Returns
+    -------
+    A datetime object
+    """
+    MONTHS = {'Jan': 1, 'January': 1, 'Feb': 2, 'February': 2, 'Mar': 3, 'March': 3, 'Apr': 4, 'April': 4,
+              'May': 5, 'May': 5, 'Jun': 6, 'June': 6, 'Jul': 7, 'July': 7, 'Aug': 8, 'August': 8,
+              'Sep': 9, 'Sept': 9, 'September': 9, 'Oct': 10, 'October': 10, 'Nov': 11, 'November': 11,
+              'Dec': 12, 'December': 12}
+
+    alt_to_datetime_kw_mapping = {'date': 'day', 'hours': 'hour', 'milliseconds': 'microsecond', 'minutes': 'minute',
+                       'month': 'month', 'seconds': 'second', 'year': 'year'}
+
+    datetime_kwargs = {'year': 0, 'month': 1, 'day': 1, 'hour': 0, 'minute': 0, 'second': 0, 'microsecond': 0}
+
+    if 'day' in dt or 'quarter' in dt:
+        raise NotImplementedError
+    if 'year' not in dt:
+        raise KeyError('A year must be provided.')
+    if 'month' not in dt:
+        dt['month'] = 1  # Default to January
+    else:
+        if isinstance(dt['month'], str):  # convert from str to number form for months
+            dt['month'] = MONTHS[dt['month']]
+    if 'date' not in dt:
+        dt['date'] = 1  # Default to the first of the month
+    if 'milliseconds' in dt:
+        dt['milliseconds'] = dt['milliseconds']*1000  # convert to microseconds
+    if 'utc' in dt:
+        raise NotImplementedError("mpl-altair currently doesn't support timezones.")
+
+    for k, v in dt.items():
+        datetime_kwargs[alt_to_datetime_kw_mapping[k]] = v
+
+    return datetime(**datetime_kwargs)